def test_attributes(self): # Check FpSemigroupInterface general attributes check_attributes(self, KnuthBendix) # Check KnuthBendix specific attributes ReportGuard(False) kb = KnuthBendix() kb.set_alphabet("abB") kb.set_identity("") kb.set_inverses("aBb") kb.add_rule("bb", "B") kb.add_rule("BaBa", "abab") self.assertFalse(kb.confluent()) kb.run() self.assertTrue(kb.confluent()) self.assertEqual( kb.active_rules(), [ ["BB", "b"], ["Bb", ""], ["aa", ""], ["bB", ""], ["bb", "B"], ["BaBa", "abab"], ["baba", "aBaB"], ["BabaB", "baBab"], ["Babab", "baBa"], ["baBaB", "Baba"], ["baBaba", "abaBab"], ], ) self.assertEqual(kb.nr_active_rules(), 11)
def test_right(self): ReportGuard(False) x = PartialPerm(range(16)) o = RightAction(type(x), type(x)) o.add_seed(x) o.add_generator( PartialPerm( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0], 16, )) o.add_generator( PartialPerm( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], [1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 16, )) o.add_generator( PartialPerm( [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], 16, )) o.add_generator( PartialPerm( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 16, )) self.assertEqual(o.size(), 65536) self.assertEqual(o.digraph().nr_scc(), 17)
def test_congruence_by_pairs1(self): ReportGuard(False) S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0])) C = CongruenceByPairs("left", S) C.add_pair([0], [1]) self.assertEqual(C.nr_classes(), 1) self.assertEqual(S.size(), 4)
def test_running_and_state(self): ReportGuard(False) kb = KnuthBendix() kb.set_alphabet("abc") kb.add_rule("aa", "") kb.add_rule("bc", "") kb.add_rule("bbb", "") kb.add_rule("ababababababab", "") kb.add_rule("abacabacabacabacabacabacabacabac", "") kb.run_for(milliseconds(500)) self.assertTrue(kb.stopped()) self.assertFalse(kb.finished()) self.assertFalse(kb.running()) self.assertTrue(kb.started()) self.assertFalse(kb.stopped_by_predicate()) self.assertTrue(kb.timed_out()) kb = KnuthBendix() kb.set_alphabet("abc") kb.add_rule("aa", "") kb.add_rule("bc", "") kb.add_rule("bbb", "") kb.add_rule("ababababababab", "") kb.add_rule("abacabacabacabacabacabacabacabac", "") kb.run_until(lambda: kb.nr_active_rules() > 100) self.assertTrue(kb.stopped()) self.assertFalse(kb.finished()) self.assertFalse(kb.running()) self.assertTrue(kb.started()) self.assertTrue(kb.stopped_by_predicate()) self.assertFalse(kb.timed_out())
def test_all(self): ReportGuard(False) S = FpSemigroup() S.set_alphabet("abcde") S.set_identity("e") S.add_rule("cacac", "aacaa") S.add_rule("acaca", "ccacc") S.add_rule("ada", "bbcbb") S.add_rule("bcb", "aadaa") S.add_rule("aaaa", "e") S.add_rule("ab", "e") S.add_rule("ba", "e") S.add_rule("cd", "e") S.add_rule("dc", "e") S.run() self.assertEqual(S.nr_rules(), 18) # self.assertEqual() self.assertTrue( S.equal_to( "abbbbbbbbbbbadddddddddddddddacccccccccccc", "aaccccccccccccccccccccccccccc", )) self.assertFalse( S.equal_to("abbbbbbbbbbbadddddddddddddddacccccccccccc", "a"))
def check_initialisation(self, t): ReportGuard(False) x = t() x.set_alphabet("ba") x.add_rule([0, 1], [1, 0]) with self.assertRaises(TypeError): x.add_rule([0, 1], [2]) S = FroidurePin(Transformation([1, 2, 0]), Transformation([1, 0, 2])) x.add_rules(S) self.assertEqual(x.size(), 2) x = t() x.set_alphabet("abBe") x.set_identity("e") x.set_inverses("aBbe") x.add_rule("bb", "B") x.add_rule("BaBa", "abab") self.assertEqual(x.size(), 24) x = t() x.set_alphabet(1) x.set_identity(0) self.assertEqual(x.size(), 1)
def test_cayley_graphs(self): ReportGuard(False) S = FroidurePin(Transformation(list(range(1, 10)) + [0])) S.run() for i in range(S.size()): self.assertEqual(S.left(i, 0), S.right(i, 0)) for i in range(S.size()): self.assertEqual(S.left_cayley_graph().get(i, 0), S.left(i, 0)) self.assertEqual(S.right_cayley_graph().get(i, 0), S.right(i, 0))
def test_state(self): ReportGuard(False) S = FroidurePin(Transformation([1, 0] + list(range(2, 10)))) S.add_generator(Transformation(list(range(1, 10)) + [0])) self.assertFalse(S.started()) S.run_for(milliseconds(10)) self.assertTrue(S.started()) self.assertTrue(S.timed_out()) self.assertTrue(S.stopped()) self.assertFalse(S.finished())
def test_run_until(self): if compare_version_numbers(libsemigroups_version(), "1.0.8"): ReportGuard(False) S = FroidurePin(Transformation([1, 0] + list(range(2, 10)))) S.add_generator(Transformation(list(range(1, 10)) + [0])) S.run_until(lambda: S.current_size() > 10) self.assertFalse(S.finished()) self.assertTrue(S.current_size() > 10) S.run_until(lambda: S.current_nr_rules() > 100) self.assertFalse(S.finished()) self.assertTrue(S.current_nr_rules() > 100)
def test_init(self): ReportGuard(False) FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0])) with self.assertRaises(KeyError): FroidurePin() with self.assertRaises(ValueError): FroidurePin(PartialPerm([1, 2], [0, 1], 3), Transformation([0, 1])) with self.assertRaises(TypeError): FroidurePin({2, 3})
def test_aaa_bug(self): ReportGuard(False) S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0])) S.run() self.assertEqual(std.distance(S.cbegin(), S.cend()), 4) self.assertEqual( list(S), [ Transformation([1, 0, 1]), Transformation([0, 0, 0]), Transformation([0, 1, 0]), Transformation([1, 1, 1]), ], )
def check_running_and_state(self, t): ReportGuard(False) x = t() x.set_alphabet("abce") x.set_identity("e") x.add_rule("aa", "e") x.add_rule("bc", "e") x.add_rule("bbb", "e") x.add_rule("ababababababab", "e") x.add_rule("abacabacabacabacabacabacabacabac", "e") x.run_for(microseconds(1)) if t != FpSemigroup or compare_version_numbers(libsemigroups_version(), "1.1.0"): # FpSemigroup doesn't behave correctly wrt run_until or run_for in # versions less than 1.1.0 self.assertTrue(x.stopped()) self.assertFalse(x.finished()) self.assertFalse(x.running()) self.assertTrue(x.started()) self.assertFalse(x.stopped_by_predicate()) self.assertTrue(x.timed_out()) x = t() x.set_alphabet("abce") x.set_identity("e") x.add_rule("aa", "e") x.add_rule("bc", "e") x.add_rule("bbb", "e") x.add_rule("ababababababab", "e") x.add_rule("abacabacabacabacabacabacabacabac", "e") n = 0 def func(): nonlocal n n += 1 return n == 2 x.run_until(func) if t != FpSemigroup or compare_version_numbers(libsemigroups_version(), "1.1.0"): self.assertTrue(x.stopped()) self.assertFalse(x.finished()) self.assertFalse(x.running()) self.assertTrue(x.started()) self.assertTrue(x.stopped_by_predicate()) self.assertFalse(x.timed_out())
def test_two(self): ReportGuard(False) kb = KnuthBendix() kb.set_alphabet("ab") kb.add_rule("aaa", "a") kb.add_rule("bbbb", "b") kb.add_rule("ba", "aab") self.assertEqual(kb.froidure_pin().size(), 11) # work around change in libsemigroups try: self.assertEqual(kb.froidure_pin()[10].string(kb), "babb") except: self.assertEqual( ll.static_cast["std::string"](kb.froidure_pin()[10]), "babb")
def test_init(self): ReportGuard(False) S = Konieczny(Transformation([1, 0, 1]), Transformation([0, 0, 0])) self.assertEqual(S.size(), 4) self.assertEqual(S.number_of_generators(), 2) with self.assertRaises(KeyError): Konieczny() with self.assertRaises(ValueError): Konieczny(PartialPerm([1, 2], [0, 1], 3), Transformation([0, 1])) with self.assertRaises(TypeError): Konieczny({2, 3})
def test_bug1_works_yes(self): ReportGuard(False) # S = FpSemigroup() # S.set_alphabet("01") # S.add_rule("000", "0") # S.add_rule("1111", "1") # S.add_rule("01110", "00") # S.add_rule("1001", "11") # S.add_rule("001010101010", "00") # S.run() # S.rules() S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0])) S.run() self.assertEqual(std.distance(S.cbegin(), S.cend()), S.size())
def test_attributes(self): ReportGuard(False) S = FroidurePin(Transformation(list(range(1, 10)) + [0])) self.assertEqual(S.current_nr_rules(), 0) self.assertEqual(S.current_size(), 1) self.assertEqual(S.degree(), 10) self.assertEqual(S.size(), 10) self.assertTrue(S.is_idempotent(9)) for i in range(8): self.assertFalse(S.is_idempotent(i)) with self.assertRaises(LibsemigroupsException): S.is_idempotent(10) self.assertTrue(S.is_monoid()) self.assertEqual(S.nr_generators(), 1) self.assertEqual(S.nr_idempotents(), 1)
def check_validation(self, t): ReportGuard(False) x = t() x.set_alphabet("ab") with self.assertRaises(TypeError): x.validate_letter("c") try: x.validate_letter("a") except Exception as e: self.fail( "unexpected exception raised for FpSemigroupInterface::validate_letter: " + e) with self.assertRaises(LibsemigroupsException): x.validate_letter(3) try: x.validate_letter(0) except Exception as e: self.fail( "unexpected exception raised for FpSemigroupInterface::validate_letter: " + e) with self.assertRaises(TypeError): x.validate_word("abc") try: x.validate_word("abab") except Exception as e: self.fail( "unexpected exception raised for FpSemigroupInterface::validate_letter: " + e) if compare_version_numbers(cppyy_version(), "1.7.1"): with self.assertRaises(LibsemigroupsException): x.validate_word([0, 1, 2]) else: with self.assertRaises(TypeError): x.validate_word([0, 1, 2]) try: x.validate_word([0, 1, 0, 1]) except Exception as e: self.fail( "unexpected exception raised for FpSemigroupInterface::validate_letter: " + e)
def test_basic(self): ReportGuard(False) s1 = PythonElement(1) s2 = PythonElement(2) s3 = PythonElement(3) self.assertEqual(s3.get_value(), 3) self.assertTrue(not s1 < s1) self.assertTrue(s1 < s2) s = s2 * s3 self.assertEqual(s.get_value(), 6) # Fails with Sage Integers S = FroidurePin([s1]) self.assertEqual(S.size(), 1) S = FroidurePin([s1, s2, s3]) S.enumerate(100) self.assertEqual(S.current_size(), 8195) self.assertEqual(S.current_nr_rules(), 6)
def check_converters(self, t): ReportGuard(False) x = t() x.set_alphabet("ba") self.assertEqual(x.char_to_uint(ord("a")), 1) self.assertEqual(x.char_to_uint(ord("b")), 0) self.assertEqual(x.string_to_word("ab"), [1, 0]) self.assertEqual(x.string_to_word("aaaaaa"), [1] * 6) with self.assertRaises(LibsemigroupsCppyyException): x.string_to_word("c") self.assertEqual(x.uint_to_char(0), "b") self.assertEqual(x.uint_to_char(1), "a") with self.assertRaises(LibsemigroupsException): x.uint_to_char(2) self.assertEqual(x.word_to_string([1, 0]), "ab") self.assertEqual(x.word_to_string([1] * 6), "a" * 6) with self.assertRaises(LibsemigroupsException): x.word_to_string([2])
def test_one(self): ReportGuard(False) kb = KnuthBendix() kb.set_alphabet("abcd") kb.add_rule("cacac", "aacaa") kb.add_rule("acaca", "ccacc") kb.add_rule("ada", "bbcbb") kb.add_rule("bcb", "aadaa") kb.add_rule("aaaa", "") kb.add_rule("ab", "") kb.add_rule("ba", "") kb.add_rule("cd", "") kb.add_rule("dc", "") kb.run() self.assertTrue(kb.confluent()) self.assertEqual(kb.nr_active_rules(), 10) self.assertEqual( kb.active_rules(), [ ["ab", ""], ["ba", ""], ["bb", "aa"], ["ca", "bd"], ["cb", "ad"], ["cd", ""], ["da", "bc"], ["db", "ac"], ["dc", ""], ["aaa", "b"], ], ) self.assertEqual( kb.rewrite("abbbbbbbbbbbadddddddddddddddacccccccccccc"), "aaccccccccccccccccccccccccccc", ) self.assertFalse( kb.equal_to("abbbbbbbbbbbadddddddddddddddacccccccccccc", "a"))
def test_constructors(self): ReportGuard(False) S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0])) T = FpSemigroup(S) self.assertFalse(T.has_froidure_pin()) if compare_version_numbers(libsemigroups_version(), "1.1.0"): self.assertEqual(S.nr_rules(), T.nr_rules()) self.assertEqual( S.rules(), [[[0, 1], [1]], [[1, 1], [1]], [[0, 0, 0], [0]], [[1, 0, 0], [1]]], ) self.assertEqual( T.rules(), [ ["\x01\x02", "\x02"], ["\x02\x02", "\x02"], ["\x01\x01\x01", "\x01"], ["\x02\x01\x01", "\x02"], ], ) self.assertEqual(T.size(), S.size())
def test_settings(self): ReportGuard(False) kb = KnuthBendix() kb.set_alphabet("abB") kb.set_identity("") kb.set_inverses("aBb") kb.add_rule("bb", "B") kb.add_rule("BaBa", "abab") self.assertEqual(kb.check_confluence_interval(10), kb) self.assertEqual(kb.max_overlap(10), kb) with self.assertRaises(ValueError): kb.max_overlap(-10) kb = KnuthBendix() kb.set_alphabet("abc") kb.add_rule("aa", "") kb.add_rule("bc", "") kb.add_rule("bbb", "") kb.add_rule("ababababababab", "") kb.add_rule("abacabacabacabacabacabacabacabac", "") kb.max_rules(100) kb.run() self.assertGreaterEqual(kb.nr_active_rules(), 100) self.assertEqual(kb.overlap_policy("ABC"), kb) self.assertEqual(kb.overlap_policy("AB_BC"), kb) self.assertEqual(kb.overlap_policy("MAX_AB_BC"), kb) with self.assertRaises(TypeError): kb.overlap_policy(-10) with self.assertRaises(ValueError): kb.overlap_policy("AVC")
def test_factorisation_and_relations(self): ReportGuard(False) S = FroidurePin(Transformation(list(range(1, 10)) + [0])) self.assertEqual(S.length_const(0), 1) with self.assertRaises(LibsemigroupsException): S.length_const(1) self.assertEqual(S.current_max_word_length(), 1) S.run() self.assertEqual(S.current_max_word_length(), 10) self.assertTrue(S.equal_to([0, 0], [0, 0])) self.assertFalse(S.equal_to([0], [0, 0])) self.assertFalse(S.equal_to([0] * 10, [0])) with self.assertRaises(LibsemigroupsException): self.assertFalse(S.equal_to([0] * 10, [1])) with self.assertRaises(LibsemigroupsException): self.assertFalse(S.equal_to([1], [0] * 10)) for i in range(S.size()): self.assertEqual(S.length_const(i), i + 1) self.assertEqual(S.length_non_const(i), i + 1) with self.assertRaises(LibsemigroupsException): S.length_non_const(10) self.assertEqual(S.letter_to_pos(0), 0) with self.assertRaises(LibsemigroupsException): S.letter_to_pos(1) S.add_generator(Transformation([1, 0] + list(range(2, 10)))) self.assertEqual(S.letter_to_pos(1), 10) S.add_generator(Transformation(list(range(1, 10)) + [0])) self.assertEqual(S.letter_to_pos(2), 0) self.assertEqual( [S.minimal_factorisation(x) for x in range(10)], [ [0], [0, 0], [0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1], ], ) with self.assertRaises(LibsemigroupsCppyyException): S.next_relation() S = FroidurePin(Transformation(list(range(1, 5)) + [0])) S.add_generator(Transformation([1, 0] + list(range(2, 5)))) self.assertEqual(S.current_nr_rules(), 0) self.assertEqual(S.word_to_pos([0, 1, 0, 1]), 18446744073709551615) self.assertEqual(S.nr_rules(), 25) self.assertEqual(S.word_to_element([0, 1, 0, 1]), Transformation([0, 3, 4, 1, 2])) self.assertEqual(S.word_to_pos([0, 1, 0, 1]), 15)
def test_add_generator(self): ReportGuard(False) S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0])) self.assertEqual(S.size(), 4) S.add_generator(Transformation([1, 2, 0])) self.assertEqual(S.size(), 24)
def test_run_for(self): ReportGuard(False) S = FroidurePin(Transformation([1, 0] + list(range(2, 10)))) S.add_generator(Transformation(list(range(1, 10)) + [0])) S.run_for(milliseconds(10))
def check_attributes(self, t): ReportGuard(False) x = t() x.set_alphabet("abBe") x.set_identity("e") x.set_inverses("aBbe") x.add_rule("bb", "B") x.add_rule("BaBa", "abab") x.run() if compare_version_numbers("1.1.0", libsemigroups_version()): self.assertEqual( x.rules(), [ ["ae", "a"], ["ea", "a"], ["be", "b"], ["eb", "b"], ["Be", "B"], ["eB", "B"], ["ee", "e"], ["aa", "e"], ["aa", "e"], ["bB", "e"], ["Bb", "e"], ["Bb", "e"], ["bB", "e"], ["ee", "e"], ["ee", "e"], ["bb", "B"], ["BaBa", "abab"], ], ) self.assertEqual(x.nr_rules(), 17) else: self.assertEqual( x.rules(), [ ["ae", "a"], ["ea", "a"], ["be", "b"], ["eb", "b"], ["Be", "B"], ["eB", "B"], ["ee", "e"], ["aa", "e"], ["bB", "e"], ["Bb", "e"], ["bb", "B"], ["BaBa", "abab"], ], ) self.assertEqual(x.nr_rules(), 12) self.assertEqual(x.alphabet(), "abBe") self.assertFalse(x.has_froidure_pin()) self.assertEqual(x.froidure_pin().size(), 24) self.assertEqual(x.identity(), "e") self.assertEqual(x.inverses(), "aBbe") self.assertFalse(x.is_obviously_infinite()) self.assertTrue(x.is_obviously_finite()) self.assertEqual(x.size(), 24)
def test_settings(self): ReportGuard(False) tc = ToddCoxeter("left") tc.set_nr_generators(1) tc.add_pair([0, 0, 0, 0], [0, 0]) try: tc.reserve(10) except: self.fail("unexpected exception thrown") tc.run() self.assertFalse(tc.is_standardized()) try: tc.standardize("lex") except: self.fail("unexpected exception thrown") self.assertTrue(tc.is_standardized()) try: tc.standardize("shortlex") except: self.fail("unexpected exception thrown") try: tc.standardize("recursive") except: self.fail("unexpected exception thrown") try: tc.standardize(True) except: self.fail("unexpected exception thrown") try: tc.standardize(False) except: self.fail("unexpected exception thrown") with self.assertRaises(TypeError): tc.standardize(1) with self.assertRaises(ValueError): tc.standardize("shooortlex") S = FroidurePin(Transformation([3, 1, 2, 1, 2]), Transformation([1, 1, 1, 2, 2])) tc = ToddCoxeter("twosided", S) try: tc.froidure_pin_policy() except: self.fail("unexpected exception thrown") try: tc.froidure_pin_policy("none") except: self.fail("unexpected exception thrown") self.assertEqual(tc.froidure_pin_policy(), "none") try: tc.froidure_pin_policy("use_relations") except: self.fail("unexpected exception thrown") self.assertEqual(tc.froidure_pin_policy(), "use_relations") try: tc.froidure_pin_policy("use_cayley_graph") except: self.fail("unexpected exception thrown") self.assertEqual(tc.froidure_pin_policy(), "use_cayley_graph") with self.assertRaises(TypeError): tc.froidure_pin_policy(1) with self.assertRaises(ValueError): tc.froidure_pin_policy("userelations") tc = ToddCoxeter("left") tc.set_nr_generators(2) tc.add_pair([0, 0, 0, 0], [0]) tc.add_pair([1, 1, 1, 1], [0]) with self.assertRaises(ValueError): tc.strategy("feelsch") with self.assertRaises(TypeError): tc.strategy(1) try: tc.strategy("felsch") except: self.fail("unexpected exception thrown") self.assertEqual(tc.strategy(), "felsch") try: tc.strategy("hlt") except: self.fail("unexpected exception thrown") self.assertEqual(tc.strategy(), "hlt") try: tc.strategy("random") except: self.fail("unexpected exception thrown") self.assertEqual(tc.strategy(), "random")
def test_related_algorithms(self): ReportGuard(False) S = FpSemigroup() S.set_alphabet("abcde") S.set_identity("e") S.add_rule("cacac", "aacaa") S.add_rule("acaca", "ccacc") S.add_rule("ada", "bbcbb") S.add_rule("bcb", "aadaa") S.add_rule("aaaa", "e") S.add_rule("ab", "e") S.add_rule("ba", "e") S.add_rule("cd", "e") S.add_rule("dc", "e") self.assertEqual( S.froidure_pin().__repr__()[:40], "<FroidurePin object with 5 generators at" ) self.assertTrue(S.has_knuth_bendix()) self.assertFalse(S.has_todd_coxeter()) # S is infinite and so it always has a KnuthBendix self.assertTrue(S.knuth_bendix().finished()) self.assertEqual( S.knuth_bendix().active_rules(), [ ["ab", "e"], ["ae", "a"], ["ba", "e"], ["bb", "aa"], ["be", "b"], ["ca", "bd"], ["cb", "ad"], ["cd", "e"], ["ce", "c"], ["da", "bc"], ["db", "ac"], ["dc", "e"], ["de", "d"], ["ea", "a"], ["eb", "b"], ["ec", "c"], ["ed", "d"], ["ee", "e"], ["aaa", "b"], ], ) self.assertEqual(S.rules(), S.knuth_bendix().rules()) S = FpSemigroup() S.set_alphabet("01") S.add_rule("000", "0") S.add_rule("1111", "1") S.add_rule("01110", "00") S.add_rule("1001", "11") S.add_rule("001010101010", "00") self.assertEqual(S.size(), 240) self.assertTrue(S.has_todd_coxeter()) self.assertFalse(S.has_knuth_bendix()) S.todd_coxeter() self.assertFalse(S.has_froidure_pin())