def test_richcmp(self):
self.assertEqual(PartialPerm([1, 2, 3], [2, 1, 0], 5),
PartialPerm([1, 2, 3], [2, 1, 0], 5))
self.assertFalse(
PartialPerm([1, 2, 3], [2, 1, 0], 5) != PartialPerm([1, 2, 3],
[2, 1, 0], 5))
self.assertFalse(
PartialPerm([1, 2, 4], [2, 1, 0], 5) == PartialPerm([1, 2, 3],
[2, 3, 0], 5))
self.assertNotEqual(PartialPerm([1, 2, 4], [2, 1, 0], 5),
PartialPerm([1, 2, 3], [2, 3, 0], 5))
self.assertFalse(
PartialPerm([1, 2, 4], [2, 1, 0], 5) < PartialPerm([1, 2, 3],
[2, 3, 0], 5))
self.assertLess(PartialPerm([1, 2], [0, 1], 3),
PartialPerm([2, 0], [0, 1], 3))
self.assertFalse(
PartialPerm([1, 2], [0, 1], 3) > PartialPerm([2, 0], [0, 1], 3))
self.assertGreater(PartialPerm([1, 2], [1, 2], 3),
PartialPerm([1, 2], [0, 1], 3))
self.assertGreaterEqual(PartialPerm([1, 2], [1, 2], 3),
PartialPerm([1, 2], [0, 1], 3))
self.assertLessEqual(PartialPerm([1, 2, 3], [2, 1, 0], 5),
PartialPerm([1, 2, 3], [2, 1, 0], 5))
with self.assertRaises(TypeError):
(PartialPerm([1, 2], [2, 1], 3) == Bipartition([1, -1], [2, 3, -2],
[-3]))
with self.assertRaises(TypeError):
PartialPerm([0, 1], [0, 1], 2) < Transformation([0, 1])
with self.assertRaises(TypeError):
PartialPerm([0, 1], [0, 1], 2) != Transformation([0, 1])
def test_init(self):
Transformation([0, 1, 2, 3])
Transformation([1, 1, 3, 2, 4, 3])
Transformation([9, 3, 1, 2, 0, 8, 1, 2, 0, 5])
# Check for CPPYY issue workaround
Transformation([])
Transformation([0, 1])
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_dealloc(self):
U, V = Transformation([1, 0, 1, 2]), Transformation([1, 1, 3, 2, 4, 3])
del U, V
with self.assertRaises(NameError):
V
with self.assertRaises(NameError):
U
def test_richcmp(self):
self.assertEqual(Bipartition([3, -4, -1], [2, -3], [4, -2], [1]),
Bipartition([4, -2], [3, -4, -1], [1], [2, -3]))
self.assertFalse(
Bipartition([3, -4, -1], [2, -3], [4, -2], [1]) != Bipartition(
[4, -2], [3, -4, -1], [1], [2, -3]))
self.assertLessEqual(Bipartition([1, -1, 3], [-3, 2, -2]),
Bipartition([1, -1], [2, 3, -2], [-3]))
self.assertLess(Bipartition([1, -1], [2, -2]),
Bipartition([1, -2], [2, -1]))
self.assertLessEqual(Bipartition([1, -1], [2, -2]),
Bipartition([1, -2], [2, -1]))
self.assertGreaterEqual(Bipartition([1, -1, 3], [-3, 2, -2]),
Bipartition([1, -2], [2, -1]))
self.assertFalse(
Bipartition([1, -1, 3], [-3, 2, -2]) > Bipartition(
[1, -1], [2, 3, -2], [-3]))
with self.assertRaises(TypeError):
(PartialPerm([1, 2], [2, 1], 3) == Bipartition([1, -1], [2, 3, -2],
[-3]))
with self.assertRaises(TypeError):
Bipartition([1, -1], [2, -2]) < Transformation([0, 1])
with self.assertRaises(TypeError):
Bipartition([1, -1], [2, -2]) != Transformation([0, 1])
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_init_fail(self):
with self.assertRaises(TypeError):
Transformation([1, 5, 26])
with self.assertRaises(TypeError):
Transformation([1])
with self.assertRaises(TypeError):
Transformation(26)
with self.assertRaises(TypeError):
Transformation(["a", "b"])
def test_036(self):
S = FroidurePin(Transformation([1, 3, 4, 2, 3]),
Transformation([3, 2, 1, 3, 3]))
tc = ToddCoxeter("twosided")
tc.set_nr_generators(2)
tc.add_pair([0], [1])
tc.add_pair([0, 0], [0])
self.assertEqual(tc.nr_classes(), 1)
with self.assertRaises(LibsemigroupsException):
tc.prefill(S.right_cayley_graph())
def test_copy_constructor(self):
S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0]))
T = S
self.assertTrue(T is S)
self.assertTrue(S is T)
T = FroidurePin(S)
self.assertFalse(S is T)
self.assertFalse(T is S)
self.assertEqual(T.size(), 4)
self.assertEqual(S.current_size(), 2)
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_idempotents(self):
S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0]))
self.assertEqual(
list(S.idempotents()),
[
Transformation([0, 0, 0]),
Transformation([0, 1, 0]),
Transformation([1, 1, 1]),
],
)
def test_init(self):
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_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_fail(self):
with self.assertRaises(TypeError):
Transformation([1, 5, 26])
with self.assertRaises(TypeError):
Transformation([1])
with self.assertRaises(TypeError):
Transformation(26)
with self.assertRaises(TypeError):
Transformation(['a', 'b'])
with self.assertRaises(TypeError):
Transformation([0.1, 1.0])
def test_init(self):
Semigroup(-1)
Semigroup(Transformation([1, 0, 1]), Transformation([0, 0, 0]))
with self.assertRaises(ValueError):
Semigroup()
with self.assertRaises(TypeError):
Semigroup(Bipartition([1, -1], [2], [-2]), Transformation([0, 1]))
with self.assertRaises(TypeError):
Semigroup({2, 3})
def test_factorisation(self):
S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0]))
self.assertEqual(S.size(), 4)
self.assertEqual([S.factorisation(x) for x in range(S.size())],
[[0], [1], [0, 0], [1, 0]])
with self.assertRaises(LibsemigroupsCppyyException):
S.factorisation(4)
# check again because of some bug in an early version of
# unwrap(_return_value)
self.assertEqual([S.factorisation(x) for x in range(S.size())],
[[0], [1], [0, 0], [1, 0]])
with self.assertRaises(LibsemigroupsCppyyException):
S.factorisation(Transformation([1, 1, 2]))
self.assertEqual([S.factorisation(x) for x in S],
[[0], [1], [0, 0], [1, 0]])
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_zno(self):
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]))
self.assertEqual(S.size(), 4)
self.assertEqual(std.distance(S.cbegin(), S.cend()), S.size())
def test_idempotents(self):
S = FroidurePin(Transformation([1, 0, 1]), Transformation([0, 0, 0]))
S.run()
self.assertEqual(
std.distance(S.cbegin_idempotents(), S.cend_idempotents()),
S.nr_idempotents(),
)
self.assertEqual(
list(S.idempotents()),
[
Transformation([0, 0, 0]),
Transformation([0, 1, 0]),
Transformation([1, 1, 1]),
],
)
def test_products(self):
S = FroidurePin(Transformation(list(range(1, 5)) + [0]))
S.run()
for i in range(5):
for j in range(5):
self.assertEqual(S.fast_product(i, j), ((i + j + 1) % 5))
self.assertEqual(S.product_by_reduction(i, j), ((i + j + 1) % 5))
def test_mul(self):
self.assertEqual(
PBR([[1, -1]], [[1]]) * PBR([[1, -1]], [[1]]), PBR([[1, -1]],
[[1]]))
self.assertEqual(
PBR([[1, -1], [-2, -1]], [[1], [-2, -1]]) *
PBR([[-1, 1, 2], [2]], [[-1, 1], [-2, 2]]),
PBR([[1, -1], [1, -1]], [[1, -1], [1, -1, -2]]))
self.assertEqual(
PBR([[-1, 1, 2], [2]], [[-1, 1], [-2, 2]]) *
PBR([[1, -1], [-2, -1]], [[1], [-2, -1]]),
PBR([[-1, 1, 2], [2]], [[-1, 1], [-2, -1]]))
self.assertEqual(
PBR([[1, -1, 3], [-2, -1, 2], [3, -2]], [[2], [-2], [1, -1, 2]]) *
PBR([[1, -1, 3], [-2, -1, 2], [3, -3, -2]],
[[1, 2], [-2, 3, -3], [1, -1]]),
PBR([[-1, 1, 2, 3], [-2, -1, 1, 2], [-2, -1, 3]],
[[-2, -1, 2], [-3, -2, -1, 1, 2], [-1, 2]]))
with self.assertRaises(TypeError):
(Transformation([0, 2, 1]) *
PBR([[1, -1, 3], [-2, -1, 2], [3, -2]], [[2], [-2], [1, -1, 2]]))
with self.assertRaises(TypeError):
(PBR([[1, -1, 3], [-2, -1, 2], [3, -2]], [[2], [-2], [1, -1, 2]]) *
Bipartition([1, -1], [2, 3, -3], [-2]))
with self.assertRaises(TypeError):
PBR([[1, -1]], [[1]]) * 0.142857
with self.assertRaises(ValueError):
PBR([[1, -1, 3], [-2, -1, 2], [3, -2]],
[[2], [-2], [1, -1, 2]]) * PBR([[1, -1]], [[1]])
def test_richcmp(self):
self.assertEqual(PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]),
PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]))
self.assertEqual(PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]),
PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]))
self.assertNotEqual(
PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]),
PBR([[1, 2], [-2, 1, 2], [3, -3]], [[2, 1], [-2, 2, 1], [1, -1]]))
self.assertTrue(
PBR([[1], [1, 2, -1]], [[1], [2, -1, 1]]) < PBR([[1], [2]],
[[-1], [-2]]))
self.assertTrue(
PBR([[1, -1, 3], [-2, -1, 2], [3, -2]], [[2], [-2], [1, -1, 2]]) >
PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]))
self.assertTrue(
PBR([[1, -1, 3], [-2, -1, 2], [3, -2]], [[2], [-2], [1, -1, 2]]) >=
PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]))
self.assertTrue(
PBR([[1, -1], [-2, -1, 2]], [[2], [-2]]) <= PBR(
[[1, -1], [-2, -1, 2]], [[2], [-2]]))
with self.assertRaises(TypeError):
(PBR([[1, -1, 3], [-2, -1, 2], [3, -2]],
[[2], [-2], [1, -1, 2]]) == Bipartition([1, -1], [2, 3, -2],
[-3]))
with self.assertRaises(TypeError):
PBR([[1, -1], [-2, -1]], [[1], [-2, -1]]) < Transformation([0, 1])
with self.assertRaises(TypeError):
(PBR([[1, -1], [-2, -1]], [[1], [-2, -1]]) != PartialPerm(
[0, 1], [1, 0], 2))
with self.assertRaises(TypeError):
PBR([[1, -1]], [[1]]) < 3
def test_mul(self):
(self.assertEqual(
BooleanMat([[True, False], [False, True]]) *
BooleanMat([[False, False], [False, True]]),
BooleanMat([[False, False], [False, True]])))
self.assertEqual(
BooleanMat([[False]]) * BooleanMat([[True]]),
BooleanMat([[False]]))
(self.assertEqual(
BooleanMat([[False, True, True], [True, True, False],
[False, False, False]]) *
BooleanMat([[False, True, False], [True, False, False],
[False, False, True]]),
BooleanMat([[True, False, True], [True, True, False],
[False, False, False]])))
with self.assertRaises(TypeError):
BooleanMat([[True, True], [False, False]]) * Transformation([1, 1])
with self.assertRaises(TypeError):
BooleanMat([[False, True, True], [True, True, False],
[False, False, False]]) * PartialPerm([0, 1], [1, 2],
3)
with self.assertRaises(TypeError):
BooleanMat([[True]]) * [[True]]
with self.assertRaises(TypeError):
BooleanMat([[True, False], [False, True]]) * Bipartition(
[1, 2], [-1], [-2])
with self.assertRaises(ValueError):
(BooleanMat([[False, True, True], [True, True, False],
[False, False, False]]) *
BooleanMat([[True, False], [False, True]]))
def test_richcmp(self):
self.assertEqual(BooleanMat([[True, False], [False, True]]),
BooleanMat([[True, False], [False, True]]))
self.assertFalse(
BooleanMat([[True, False], [False, True]]) != BooleanMat(
[[True, False], [False, True]]))
self.assertFalse(
BooleanMat([[True, False], [False, True]]) == BooleanMat(
[[False, False], [False, True]]))
self.assertLess(BooleanMat([[False]]), BooleanMat([[True]]))
self.assertFalse(
BooleanMat([[False, True, True], [True, True, False],
[False, False, False]]) < BooleanMat([[
False, True, False
], [True, False, False], [False, False, True]]))
self.assertLessEqual(BooleanMat([[False]]), BooleanMat([[False]]))
self.assertGreater(BooleanMat([[True, False], [False, True]]),
BooleanMat([[True, False], [False, False]]))
self.assertFalse(
BooleanMat([[True, False], [False, True]]) > BooleanMat(
[[True, False], [False, True]]))
self.assertGreaterEqual(BooleanMat([[False]]), BooleanMat([[False]]))
with self.assertRaises(TypeError):
(Bipartition([1, -2], [-1, 2]) >= BooleanMat([False, False],
[True, False]))
with self.assertRaises(TypeError):
BooleanMat([False, False], [True, False]) < Transformation([0, 1])
with self.assertRaises(TypeError):
(BooleanMat([True, False], [False, True]) == PartialPerm([0], [1],
2))
def test_prefixes_and_suffixes(self):
S = FroidurePin(Transformation(list(range(1, 5)) + [0]))
self.assertEqual(S.prefix(0), 18446744073709551615)
for i in range(1, S.size()):
self.assertEqual(S.prefix(i), i - 1)
self.assertEqual(S.suffix(i), i - 1)
self.assertEqual(S.first_letter(i), 0)
self.assertEqual(S.final_letter(i), 0)
def test_mul(self):
(self.assertEqual(
Transformation([1, 3, 2, 1]) * Transformation([0, 3, 2, 2]),
Transformation([3, 2, 2, 3]),
))
self.assertEqual(
Transformation([2, 2, 2]) * Transformation([1, 0, 1]),
Transformation([1, 1, 1]),
)
(self.assertEqual(
Transformation([0, 1, 2, 3, 4, 5]) *
Transformation([3, 2, 2, 3, 1, 4]),
Transformation([3, 2, 2, 3, 1, 4]),
))
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_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_deleted_methods(self):
S = FroidurePin(Transformation([1, 0, 1]))
with self.assertRaises(LibsemigroupsCppyyException):
S.add_generators()
with self.assertRaises(LibsemigroupsCppyyException):
S.copy_add_generators()
with self.assertRaises(LibsemigroupsCppyyException):
S.closure()
with self.assertRaises(LibsemigroupsCppyyException):
S.copy_closure()
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())