def check_froidure_pin_transf2(T):
add = list(range(3, 16)) if T is Transf16 else []
gens = [
T.make([1, 0, 2] + add),
T.make([1, 2, 0] + add),
]
S = FroidurePin(gens)
S.run()
assert list(S) == [
T.make([1, 0, 2] + add),
T.make([1, 2, 0] + add),
T.make([0, 1, 2] + add),
T.make([2, 1, 0] + add),
T.make([0, 2, 1] + add),
T.make([2, 0, 1] + add),
]
assert list(S.sorted()) == [
T.make([0, 1, 2] + add),
T.make([0, 2, 1] + add),
T.make([1, 0, 2] + add),
T.make([1, 2, 0] + add),
T.make([2, 0, 1] + add),
T.make([2, 1, 0] + add),
]
def check_initialisation(self, t):
ReportGuard(False)
x = t()
x.set_alphabet("ba")
x.add_rule([0, 1], [1, 0])
with self.assertRaises(RuntimeError):
x.add_rule([0, 1], [2])
S = FroidurePin([Transf([1, 2, 0]), Transf([1, 0, 2])])
S.run()
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_froidure_pin_max_plus(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
gens = [MaxPlusMat([[0, -3], [-2, -10]])]
assert FroidurePin(gens).size() == 2
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_int_mat(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
gens = [IntMat([[0, -3], [-2, -10]])]
assert FroidurePin(gens).size() == 64
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_ntp(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
gens = [Matrix(MatrixKind.NTP, 5, 7, [[1, 1], [1, 1]])]
assert FroidurePin(gens).size() == 6
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_min_plus(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
x = MinPlusMat(2, 2)
gens = [MinPlusMat([[1, 0], [0, x.zero()]])]
assert FroidurePin(gens).size() == 3
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def check_constructors(coll):
ReportGuard(False)
# default constructor
S = FroidurePin(coll[0])
S.add_generators(coll[1:])
# copy constructor
U = FroidurePin(S)
assert S is not U
assert S.number_of_generators() == U.number_of_generators()
assert S.current_size() == U.current_size()
def test_froidure_pin_min_plus_trunc(
checks_for_froidure_pin, checks_for_generators
):
ReportGuard(False)
gens = [Matrix(MatrixKind.MinPlusTrunc, 11, [[1, 0], [0, 1]])]
assert FroidurePin(gens).size() == 2
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_proj_max_plus(
checks_for_froidure_pin, checks_for_generators
):
ReportGuard(False)
x = Matrix(MatrixKind.ProjMaxPlus, 2, 2)
gens = [Matrix(MatrixKind.ProjMaxPlus, [[1, 0], [0, x.zero()]])]
assert FroidurePin(gens).size() == 2
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_runner_transf():
for T in (Transf16, Transf1, Transf2, Transf4):
add = list(range(8, 16)) if T is Transf16 else []
S = FroidurePin(T.make([1, 7, 2, 6, 0, 4, 1, 5] + add))
S.add_generator(T.make([2, 4, 6, 1, 4, 5, 2, 7] + add))
S.add_generator(T.make([3, 0, 7, 2, 4, 6, 2, 4] + add))
S.add_generator(T.make([3, 2, 3, 4, 5, 3, 0, 1] + add))
S.add_generator(T.make([4, 3, 7, 7, 4, 5, 0, 4] + add))
S.add_generator(T.make([5, 6, 3, 0, 3, 0, 5, 1] + add))
S.add_generator(T.make([6, 0, 1, 1, 1, 6, 3, 4] + add))
S.add_generator(T.make([7, 7, 4, 0, 6, 4, 1, 7] + add))
check_runner(S, timedelta(microseconds=1000))
def test_froidure_pin_bmat8(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
gens = [
BMat8([[0, 1], [1, 0]]),
BMat8([[1, 0], [1, 1]]),
BMat8([[1, 0], [0, 0]]),
]
assert FroidurePin(gens).size() == 16
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_bmat(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
gens = [
Matrix(MatrixKind.Boolean, [[0, 1], [1, 0]]),
Matrix(MatrixKind.Boolean, [[1, 0], [1, 1]]),
Matrix(MatrixKind.Boolean, [[1, 0], [0, 0]]),
]
assert FroidurePin(gens).size() == 16
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_bipart(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
T = Bipartition
gens = [
T.make([0, 1, 1, 0]),
T.make([0, 1, 2, 1]),
T.make([0, 0, 0, 0]),
]
assert FroidurePin(gens).size() == 15
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_perm(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
for T in (Perm16, Perm1, Perm2, Perm4):
add = list(range(4, 16)) if T is Perm16 else []
gens = [
T.make([1, 0] + list(range(2, 4)) + add),
T.make(list(range(1, 4)) + [0] + add),
]
assert FroidurePin(gens).size() == 24
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_pbr(checks_for_froidure_pin, checks_for_generators):
ReportGuard(False)
T = PBR
gens = [
T.make([[], [0]]),
T.make([[0, 1], [0]]),
T.make([[1], []]),
T.make([[1], [0, 1]]),
]
assert FroidurePin(gens).size() == 15
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_036(self):
ReportGuard(False)
S = FroidurePin(Transf([1, 3, 4, 2, 3]), Transf([3, 2, 1, 3, 3]))
tc = ToddCoxeter(congruence_kind.twosided, S)
tc.set_number_of_generators(2)
tc.add_pair([0], [1])
tc.add_pair([0, 0], [0])
self.assertEqual(tc.number_of_classes(), 1)
def test_runner_perm():
for T in (Perm16, Perm1, Perm2, Perm4):
add = list(range(9, 16)) if T is Perm16 else []
gens = [
T.make([1, 0] + list(range(2, 9)) + add),
T.make(list(range(1, 9)) + [0] + add),
]
S = FroidurePin(gens)
check_runner(S, timedelta(microseconds=1000))
def test_froidure_pin_kbe(checks_for_froidure_pin):
ReportGuard(False)
kb = KnuthBendix()
kb.set_alphabet(2)
kb.add_rule([0, 0, 0, 0], [0])
kb.add_rule([1, 1, 1, 1], [1])
kb.add_rule([0, 1], [1, 0])
assert kb.size() == 15
for check in checks_for_froidure_pin:
check(FroidurePin(kb.froidure_pin()))
def test_froidure_pin_pperm(checks_for_froidure_pin, checks_for_generators):
for T in (PPerm16, PPerm1, PPerm2, PPerm4):
gens = [
T.make([0, 1, 2], [1, 0, 2], 16),
T.make([0, 1, 2], [1, 2, 0], 16),
T.make([0, 1], [0, 1], 16),
]
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
def test_froidure_pin_tce(checks_for_froidure_pin):
ReportGuard(False)
tc = ToddCoxeter(congruence_kind.twosided)
tc.set_number_of_generators(2)
tc.add_pair([0, 0, 0, 0], [0])
tc.add_pair([1, 1, 1, 1], [1])
tc.add_pair([0, 1], [1, 0])
assert tc.number_of_classes() == 15
for check in checks_for_froidure_pin:
check(FroidurePin(tc.quotient_froidure_pin()))
def test_froidure_pin_transf(checks_for_froidure_pin, checks_for_generators):
for T in (Transf16, Transf1, Transf2, Transf4):
add = list(range(3, 16)) if T is Transf16 else []
gens = [
T.make([1, 0, 2] + add),
T.make([1, 2, 0] + add),
T.make([0, 0, 1] + add),
]
for check in checks_for_generators:
check(gens)
for check in checks_for_froidure_pin:
check(FroidurePin(gens))
check_froidure_pin_transf1(T)
check_froidure_pin_transf2(T)
def test_settings(self):
ReportGuard(False)
tc = ToddCoxeter(congruence_kind.left)
tc.set_number_of_generators(1)
tc.add_pair([0, 0, 0, 0], [0, 0])
tc.reserve(10)
tc.run()
self.assertFalse(tc.is_standardized())
tc.standardize(order.lex)
self.assertTrue(tc.is_standardized())
tc.standardize(order.shortlex)
tc.standardize(order.recursive)
tc.standardize(True)
tc.standardize(False)
tc.standardize(1)
with self.assertRaises(TypeError):
tc.standardize("shooortlex")
S = FroidurePin(Transf([3, 1, 2, 1, 2]), Transf([1, 1, 1, 2, 2]))
tc = ToddCoxeter(congruence_kind.twosided, S)
tc.froidure_pin_policy()
tc.froidure_pin_policy(fpp.none)
self.assertEqual(tc.froidure_pin_policy(), fpp.none)
tc.froidure_pin_policy(fpp.use_relations)
self.assertEqual(tc.froidure_pin_policy(), fpp.use_relations)
tc.froidure_pin_policy(fpp.use_cayley_graph)
self.assertEqual(tc.froidure_pin_policy(), fpp.use_cayley_graph)
with self.assertRaises(TypeError):
tc.froidure_pin_policy(1)
with self.assertRaises(TypeError):
tc.froidure_pin_policy("userelations")
tc = ToddCoxeter(congruence_kind.left)
tc.set_number_of_generators(2)
tc.add_pair([0, 0, 0, 0], [0])
tc.add_pair([1, 1, 1, 1], [0])
with self.assertRaises(TypeError):
tc.strategy("feelsch")
with self.assertRaises(TypeError):
tc.strategy(1)
tc.strategy(strategy.felsch)
self.assertEqual(tc.strategy(), strategy.felsch)
tc.strategy(strategy.hlt)
self.assertEqual(tc.strategy(), strategy.hlt)
tc.strategy(strategy.random)
self.assertEqual(tc.strategy(), strategy.random)
def test_attributes(self):
ReportGuard(False)
tc = ToddCoxeter(congruence_kind.left)
tc.set_number_of_generators(1)
tc.add_pair([0, 0, 0, 0, 0, 0], [0, 0, 0])
self.assertEqual(tc.number_of_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]), tril.false)
self.assertEqual(tc.kind(), congruence_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.number_of_generators(), 1)
self.assertEqual(tc.number_of_generating_pairs(), 1)
self.assertTrue(tc.less([0], [0, 0]))
S = FroidurePin(Transf([1, 2, 2]), Transf([2, 0, 1]))
tc = ToddCoxeter(congruence_kind.twosided, S)
self.assertEqual(tc.number_of_classes(), 24)
self.assertTrue(tc.has_parent_froidure_pin())
self.assertEqual(tc.parent_froidure_pin().size(), 24)
self.assertEqual(tc.quotient_froidure_pin().size(), 24)
K = KnuthBendix()
K.set_alphabet("a")
K.add_rule("aaaa", "aa")
tc = ToddCoxeter(congruence_kind.left, K)
self.assertEqual(tc.number_of_classes(), 3)
tc = ToddCoxeter(congruence_kind.twosided)
tc.set_number_of_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 check_generators(coll):
ReportGuard(False)
S = FroidurePin(coll[0])
S.add_generators(coll[1:])
for i, x in enumerate(coll):
assert S.generator(i) == x
with pytest.raises(RuntimeError):
S.generator(len(coll))
U = FroidurePin(coll[0])
for x in coll[1:]:
U.add_generator(x)
assert S.number_of_generators() == U.number_of_generators()
assert S.size() == U.size()
S.closure(coll)
assert S.number_of_generators() == len(coll)
U = S.copy_closure(coll)
assert U.number_of_generators() == S.number_of_generators()
assert U.size() == S.size()
assert U is not S
U = S.copy_add_generators(coll)
assert U.number_of_generators() == 2 * S.number_of_generators()
assert U.size() == S.size()
assert U is not S
def test_000_iterators(self):
ReportGuard(False)
tc = ToddCoxeter(congruence_kind.left)
tc.set_number_of_generators(2)
tc.add_pair([0, 0, 0, 0], [0])
tc.add_pair([1, 1, 1, 1], [1])
tc.add_pair([0, 1], [1, 0])
self.assertEqual(
list(tc.generating_pairs()),
[([0, 0, 0, 0], [0]), ([1, 1, 1, 1], [1]), ([0, 1], [1, 0])],
)
self.assertEqual(
list(tc.normal_forms()),
[
[0],
[1],
[0, 0],
[1, 0],
[1, 1],
[0, 0, 0],
[1, 0, 0],
[1, 1, 0],
[1, 1, 1],
[1, 0, 0, 0],
[1, 1, 0, 0],
[1, 1, 1, 0],
[1, 1, 0, 0, 0],
[1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
],
)
S = FroidurePin(Transf([1, 3, 4, 2, 3]), Transf([3, 2, 1, 3, 3]))
tc = ToddCoxeter(congruence_kind.left, S)
tc.add_pair(
S.factorisation(Transf([3, 4, 4, 4, 4])),
S.factorisation(Transf([3, 1, 3, 3, 3])),
)
self.assertEqual(
list(tc.non_trivial_classes()),
[[
[0, 0, 1],
[1, 0, 1],
[0, 0, 0, 1],
[0, 1, 0, 1],
[1, 0, 0, 1],
[0, 0, 0, 0, 1],
[0, 0, 1, 0, 1],
[1, 0, 0, 0, 1],
[1, 0, 1, 0, 1],
[0, 0, 0, 1, 0, 1],
[0, 1, 0, 0, 0, 1],
[0, 1, 0, 1, 0, 1],
[1, 0, 0, 1, 0, 1],
[0, 0, 0, 0, 1, 0, 1],
[0, 0, 1, 0, 0, 0, 1],
[1, 0, 0, 0, 1, 0, 1],
[0, 1, 0, 0, 0, 1, 0, 1],
[0, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 1, 0, 1],
[0, 1, 0, 0, 0, 1, 1, 0, 0],
]],
)
def test_constructors(self):
# pylint: disable=too-many-statements
ToddCoxeter(congruence_kind.left)
ToddCoxeter(congruence_kind.right)
ToddCoxeter(congruence_kind.twosided)
with self.assertRaises(TypeError):
ToddCoxeter(45)
with self.assertRaises(TypeError):
ToddCoxeter("lft")
with self.assertRaises(TypeError):
ToddCoxeter(
congruence_kind.twosided,
congruence_kind.left,
congruence_kind.right,
)
S = FroidurePin(Transf([0, 0, 1, 2, 3]))
with self.assertRaises(TypeError):
ToddCoxeter(S)
ToddCoxeter(congruence_kind.twosided, S)
K = KnuthBendix()
with self.assertRaises(RuntimeError):
ToddCoxeter(congruence_kind.left, K)
K.set_alphabet("a")
ToddCoxeter(congruence_kind.left, K)
T = ToddCoxeter(congruence_kind.left)
if libsemigroups_version() == "2.0.3":
with self.assertRaises(ValueError):
ToddCoxeter(congruence_kind.left, T)
else:
ToddCoxeter(congruence_kind.left, T)
T.set_number_of_generators(1)
with self.assertRaises(RuntimeError):
ToddCoxeter(congruence_kind.right, T)
with self.assertRaises(RuntimeError):
ToddCoxeter(congruence_kind.twosided, T)
ToddCoxeter(congruence_kind.left, T)
T = ToddCoxeter(congruence_kind.right)
if libsemigroups_version() == "2.0.3":
with self.assertRaises(ValueError):
ToddCoxeter(congruence_kind.right, T)
else:
ToddCoxeter(congruence_kind.right, T)
T.set_number_of_generators(1)
with self.assertRaises(RuntimeError):
ToddCoxeter(congruence_kind.left, T)
with self.assertRaises(RuntimeError):
ToddCoxeter(congruence_kind.twosided, T)
ToddCoxeter(congruence_kind.right, T)
T = ToddCoxeter(congruence_kind.twosided)
if libsemigroups_version() == "2.0.3":
with self.assertRaises(ValueError):
ToddCoxeter(congruence_kind.twosided, T)
else:
ToddCoxeter(congruence_kind.twosided, T)
T.set_number_of_generators(1)
ToddCoxeter(congruence_kind.left, T)
ToddCoxeter(congruence_kind.right, T)
ToddCoxeter(congruence_kind.twosided, T)
tc = ToddCoxeter(congruence_kind.left)
tc.set_number_of_generators(2)
with self.assertRaises(RuntimeError):
tc.add_pair([0, 0, 1, 0], [1, 1, 2])
def check_froidure_pin_transf1(T):
ReportGuard(False)
if T is Transf16:
add = list(range(8, 16))
else:
add = []
S = FroidurePin(T.make([1, 7, 2, 6, 0, 4, 1, 5] + add))
S.add_generator(T.make([2, 4, 6, 1, 4, 5, 2, 7] + add))
S.add_generator(T.make([3, 0, 7, 2, 4, 6, 2, 4] + add))
S.add_generator(T.make([3, 2, 3, 4, 5, 3, 0, 1] + add))
S.add_generator(T.make([4, 3, 7, 7, 4, 5, 0, 4] + add))
S.add_generator(T.make([5, 6, 3, 0, 3, 0, 5, 1] + add))
S.add_generator(T.make([6, 0, 1, 1, 1, 6, 3, 4] + add))
S.add_generator(T.make([7, 7, 4, 0, 6, 4, 1, 7] + add))
S.reserve(600000)
assert S.number_of_generators() == 8
assert S.current_size() == 8
assert S.current_number_of_rules() == 0
S.enumerate(100)
assert S.current_size() == 8200
assert S.current_number_of_rules() == 1049
if T == Transf16:
assert S.degree() == 16
else:
assert S.degree() == 8
def test_runner_pperm():
for T in (PPerm16, PPerm1, PPerm2, PPerm4):
S = FroidurePin(T.make(list(range(9)), [1, 0] + list(range(2, 9)), 16))
S.add_generator(T.make(list(range(9)), list(range(1, 9)) + [0], 16))
S.add_generator(T.make([0, 1], [0, 1], 16))
check_runner(S, timedelta(microseconds=1000))