def test_attributes(self):
tc = ToddCoxeter("left")
tc.set_nr_generators(1)
tc.add_pair([0, 0, 0, 0, 0, 0], [0, 0, 0])
self.assertEqual(tc.nr_classes(), 5)
self.assertTrue(tc.contains([0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0]))
self.assertFalse(tc.contains([0, 0, 0], [0, 0]))
self.assertEqual(tc.const_contains([0, 0, 0], [0, 0]), 0)
self.assertEqual(tc.kind(), "left")
self.assertFalse(tc.empty())
self.assertEqual(tc.class_index_to_word(1), [0, 0])
self.assertEqual(tc.word_to_class_index([0, 0]), 1)
self.assertFalse(tc.has_parent_froidure_pin())
self.assertEqual(tc.nr_generators(), 1)
self.assertEqual(tc.nr_generating_pairs(), 1)
self.assertTrue(tc.less([0], [0, 0]))
S = FroidurePin(Transformation([1, 2, 2]), Transformation([2, 0, 1]))
tc = ToddCoxeter("twosided", S)
self.assertEqual(tc.nr_classes(), 24)
self.assertTrue(tc.has_parent_froidure_pin())
try:
tc.parent_froidure_pin()
except:
self.fail("unexpected exception thrown")
try:
tc.quotient_froidure_pin()
except:
self.fail("unexpected exception thrown")
K = KnuthBendix()
K.set_alphabet("a")
K.add_rule("aaaa", "aa")
tc = ToddCoxeter("left", K)
self.assertEqual(tc.nr_classes(), 3)
tc = ToddCoxeter("twosided")
tc.set_nr_generators(1)
self.assertTrue(tc.is_quotient_obviously_infinite())
self.assertFalse(tc.is_quotient_obviously_finite())
tc.add_pair([0, 0, 0], [0])
self.assertFalse(tc.is_quotient_obviously_infinite())
tc.run()
self.assertTrue(tc.is_quotient_obviously_finite())
def test_one(self):
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):
try:
ToddCoxeter("left")
except:
self.fail("unexpected exception thrown")
try:
ToddCoxeter("right")
except:
self.fail("unexpected exception thrown")
try:
ToddCoxeter("twosided")
except:
self.fail("unexpected exception thrown")
with self.assertRaises(TypeError):
ToddCoxeter(45)
with self.assertRaises(ValueError):
ToddCoxeter("lft")
with self.assertRaises(TypeError):
ToddCoxeter("twosided", "left", "right")
S = FroidurePin(Transformation([0, 0, 1, 2, 3]))
with self.assertRaises(TypeError):
ToddCoxeter(S)
try:
ToddCoxeter("twosided", S)
except:
self.fail("unexpected exception thrown")
K = KnuthBendix()
with self.assertRaises(TypeError):
ToddCoxeter("left", K)
K.set_alphabet("a")
try:
ToddCoxeter("left", K)
except:
self.fail("unexpected exception thrown")
T = ToddCoxeter("left")
with self.assertRaises(TypeError):
ToddCoxeter("left", T)
T.set_nr_generators(1)
with self.assertRaises(TypeError):
ToddCoxeter("right", T)
with self.assertRaises(TypeError):
ToddCoxeter("twosided", T)
try:
ToddCoxeter("left", T)
except:
self.fail("unexpected exception thrown")
T = ToddCoxeter("right")
with self.assertRaises(TypeError):
ToddCoxeter("right", T)
T.set_nr_generators(1)
with self.assertRaises(TypeError):
ToddCoxeter("left", T)
with self.assertRaises(TypeError):
ToddCoxeter("twosided", T)
try:
ToddCoxeter("right", T)
except:
self.fail("unexpected exception thrown")
T = ToddCoxeter("twosided")
with self.assertRaises(TypeError):
ToddCoxeter("twosided", T)
T.set_nr_generators(1)
try:
ToddCoxeter("left", T)
except:
self.fail("unexpected exception thrown")
try:
ToddCoxeter("right", T)
except:
self.fail("unexpected exception thrown")
try:
ToddCoxeter("twosided", T)
except:
self.fail("unexpected exception thrown")
tc = ToddCoxeter("left")
tc.set_nr_generators(2)
with self.assertRaises(LibsemigroupsException):
tc.add_pair([0, 0, 1, 0], [1, 1, 2])
def test_two(self):
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_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_initialisation(self):
check_initialisation(self, KnuthBendix)
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.size(), 24)
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_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")