def test_insert(self):
self.assertEqual(self.group.order(), 1)
self.group.insert(Perm()(0, 1, 2)(3, 5, 4))
self.assertEqual(self.group.order(), 3)
self.group.insert(Perm()(0, 3)(1, 4)(2, 5))
self.assertEqual(self.group.order(), 6)
self.group.insert(Perm()(0, 6)(1, 7)(2, 8))
self.assertEqual(self.group.order(), 6 * 9)
def test_orbits2(self):
self.N = 4
self.group = Group()
self.group.insert(Perm()(0, 1))
self.group.insert(Perm()(2, 3))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1], [2, 3]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertEqual(self.group.orbits([0, 1, 2]), [[0, 1], [2, 3]])
def test_lehmer(self):
size = 4
p = Perm()(0,3)(1,2) # [3, 2, 1, 0]
self.assertEqual(p.inversion_vector(size), [3, 2, 1, 0])
self.assertEqual(self.E.rank_lex(size), 0)
self.assertEqual(self.R1.rank_lex(size), 7)
self.assertEqual(self.P1.rank_lex(size), 2)
self.assertEqual(self.H.rank_lex(size), 10)
self.assertEqual(Perm.unrank_lex(size, 17), Perm()(0, 2, 1, 3))
def test_group(self):
self.assertEqual(self.group.order(), 4)
self.assertFalse(self.group.is_trivial())
self.assertTrue(Perm() in self.group)
self.assertTrue(self.H in self.group)
points = range(self.N)
self.assertFalse(Perm()(*points) in self.group)
self.assertEqual(self.group.orbits(points), [[0, 4, 2, 1], [3, 5]])
self.assertEqual(len(self.group.orbits(points)), 2)
self.assertFalse(self.group.is_transitive(points))
def test_is_normal(self):
a = Perm()(0, 1, 2)
b = Perm()(0, 1)
c = Perm()(0, 2, 1)
G = Group()
G.insert(a)
G.insert(b)
self.assertEqual(G.order(), 6) # G = S_3
H = Group()
H.insert(a)
H.insert(c)
self.assertEqual(H.order(), 3) # H = A_3
self.assertTrue(H.is_normal(G))
def test_alt_5(self):
self.N = 5
self.group = Group()
self.assertEqual(self.group.order(), 1)
self.group.insert(Perm()(0, 1, 2))
self.assertEqual(self.group.order(), 3)
self.group.insert(Perm()(1, 2, 3))
self.assertEqual(self.group.order(), 12)
self.group.insert(Perm()(2, 3, 4))
self.assertEqual(self.group.order(), 60)
self.assertFalse(Perm()(0, 1) in self.group)
self.assertTrue(Perm()(*range(self.N)) in self.group) # N is odd
self.assertTrue(self.group.is_transitive(points=range(self.N)))
self.assertEqual(len(self.group.orbits(range(self.N))), 1)
def setUp(self):
self.N = 6
self.assertTrue(self.N > 2)
self.group = Group()
self.H = Perm()(*range(self.N))
self.group.insert(self.H)
left = 1
right = self.N - 1
perm = Perm()
while left < right:
perm = perm * Perm()(left, right)
left = left + 1
right = right - 1
self.group.insert(perm)
def test_normal_closure(self):
n = 5
# Tworze grupe cykliczna C_5.
C5 = Group()
C5.insert(Perm()(*range(n)))
self.assertEqual(C5.order(), n)
# Make Sym(5).
S5 = Group()
S5.insert(Perm()(*range(n)))
S5.insert(Perm()(0, 1))
self.assertEqual(S5.order(), 120)
A5 = S5.normal_closure(C5)
self.assertEqual(A5.order(), 60)
for perm in A5.iterperms():
self.assertTrue(perm.is_even())
def test_normal_closure(self):
n = 5
# Make Cyclic(5).
C5 = Group()
C5.insert(Perm()(*range(n)))
self.assertEqual(C5.order(), n)
# Make Sym(5).
S5 = Group()
S5.insert(Perm()(*range(n)))
S5.insert(Perm()(0, 1))
self.assertEqual(S5.order(), 120)
A5 = S5.normal_closure(C5) # we get Alt(5)
self.assertEqual(A5.order(), 60)
for perm in A5:
self.assertTrue(perm.is_even())
def test_orbits4(self):
self.N = 10
self.group = Group()
self.group.insert(Perm()(0, 1, 2))
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(
self.group.is_transitive(strict=False, points=range(self.N)))
def test_cyclic6(self):
points = range(5)
C6 = Group()
C6.insert(Perm()(0, 1, 2)(3, 4))
self.assertEqual(C6.order(), 6)
self.assertEqual(C6.orbits(points), [[0, 2, 1], [3, 4]])
self.assertEqual(len(C6.orbits(points)), 2)
self.assertFalse(C6.is_transitive(points))
def test_is_subgroup(self):
self.group2 = Group()
# Make cyclic group C_N.
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
def test_orbits1(self):
self.N = 3
self.group = Group()
self.group.insert(Perm()(0, 1))
self.assertEqual(self.group.orbits(range(self.N)), [[0, 1], [2]])
self.assertEqual(self.group.orbits([0, 1]), [[0, 1]])
self.assertFalse(self.group.is_transitive(points=range(self.N)))
self.assertTrue(
self.group.is_transitive(points=range(self.N), strict=False))
def test_is_subgroup(self):
self.group2 = Group()
# Tworze grupe cykliczna C_N.
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
self.assertTrue(self.group2.is_subgroup(self.group1))
self.assertTrue(self.group2.is_abelian())
self.assertFalse(self.group1.is_abelian())
self.assertFalse(self.group2.is_normal(self.group1))
def test_alt_n(self):
self.N = 5
self.assertTrue(self.N > 2)
self.group = Group()
order = 1
for i in range(self.N - 2):
self.group.insert(Perm()(i, i + 1, i + 2))
order = order * (i + 3)
self.assertEqual(self.group.order(), order)
self.assertTrue(self.group.is_transitive(points=range(self.N)))
self.assertEqual(len(self.group.orbits(range(self.N))), 1)
def test_centralizer(self):
# Tworze grupe cykliczna.
self.group2 = Group()
self.group2.insert(Perm()(*range(self.N)))
self.assertEqual(self.group2.order(), self.N)
# centrum grupy abelowej cyklicznej to cala grupa
self.group3 = self.group2.center()
self.assertEqual(self.group3.order(), self.N)
# Dalej dla grupy symetrycznej.
self.group2 = self.group1.center()
self.assertEqual(self.group2.order(), 1)
def action(self, points):
"""Return a new group induced by the action."""
# Sprawdzamy, czy grupa jest tranzytywna na punktach.
if not self.is_transitive(points):
raise TypeError("the group is not transitive on points")
adict = dict()
for i, pt in enumerate(points):
adict[pt] = i
new_group = Group()
for perm in self:
new_data = [adict[perm[pt]] for pt in points]
new_group.insert(Perm(data=new_data))
return new_group
def setUp(self):
self.N = 21
self.group = Group()
self.order_rubik2 = 3674160 # 6 * 9 * 12 * 15 * 18 * 21
R1 = Perm()(2, 13, 19, 4) * Perm()(3, 11, 0, 6) * Perm()(7, 8, 10, 9)
D1 = Perm()(5, 9, 13, 16) * Perm()(6, 10, 14, 17) * Perm()(18, 19, 0,
20)
B1 = Perm()(1, 16, 0, 8) * Perm()(2, 15, 20, 10) * Perm()(11, 12, 14,
13)
R2 = R1 * R1
R3 = R1 * R2
D2 = D1 * D1
D3 = D1 * D2
B2 = B1 * B1
B3 = B1 * B2
self.generators = [R1, D1, B1]
# cwiartki i polowki
self.face_turns = [R1, R2, R3, D1, D2, D3, B1, B2, B3]
# tylko cwiartki
self.quarter_turns = [R1, R3, D1, D3, B1, B3]
def setUp(self):
self.E = Perm()
self.R1 = Perm()(0, 1)(2, 3)
self.R2 = Perm()(0, 2)(1, 3)
self.P1 = Perm()(1, 2)
self.H = Perm()(0, 1, 3, 2)
def test_insert(self):
self.assertEqual(self.group.order(), 2 * self.N)
self.assertTrue(Perm() in self.group)
self.assertTrue(self.H in self.group)
def __init__(self):
"""Load up a Group instance."""
self.add(Perm())
def setUp(self):
self.N = 4
# Tworze grupe symetryczna.
self.group1 = Group()
self.group1.insert(Perm()(0, 1))
self.group1.insert(Perm()(*range(self.N)))
def setUp(self):
# The cyclic group from the paper by Knuth.
self.N = 6
self.H = Perm()(0, 1, 2, 4)(3, 5)
self.group = Group()
self.group.insert(self.H)
def __init__(self):
"""Load up a Group instance."""
perm = Perm()
self[perm.label()] = perm
def test_orbits3(self): # grupa cykliczna
self.N = 10
self.group = Group()
self.group.insert(Perm()(*range(self.N)))
self.assertTrue(self.group.is_transitive(points=range(self.N)))
class TestPerm(unittest.TestCase):
def setUp(self):
self.E = Perm()
self.R1 = Perm()(0, 1)(2, 3)
self.R2 = Perm()(0, 2)(1, 3)
self.P1 = Perm()(1, 2)
self.H = Perm()(0, 1, 3, 2)
def test_init(self):
self.assertEqual(self.P1, Perm()(*(1, 2)))
self.assertEqual(self.P1, Perm(data=[0, 2, 1]))
self.assertEqual(Perm(), Perm()(1)(2)) # singletony
def test_repr(self):
self.assertEqual(repr(self.E), "Perm()")
self.assertEqual(repr(self.R1), "Perm()(0, 1)(2, 3)")
self.assertEqual(repr(self.R2), "Perm()(0, 2)(1, 3)")
self.assertEqual(repr(self.P1), "Perm()(1, 2)")
self.assertEqual(repr(self.H), "Perm()(0, 1, 3, 2)")
def test_label(self):
self.assertEqual(self.E.label(), "0")
self.assertEqual(self.E.label(3), "012")
self.assertEqual(self.R1.label(), "1032")
self.assertEqual(self.P1.label(), "021")
self.assertEqual(self.H.label(), "1302")
def test_identity(self):
self.assertTrue(self.E.is_identity())
self.assertFalse(self.R1.is_identity())
self.assertFalse(self.H.is_identity())
def test_mul(self):
self.assertEqual(self.E * self.E, self.E)
self.assertEqual(self.R1 * self.E, self.R1)
self.assertEqual(self.R1 * self.R1, self.E)
self.assertNotEqual(self.R1 * self.R2, self.E)
def test_invert(self):
self.assertEqual(~self.E, self.E)
self.assertEqual(~self.R1, self.R1)
self.assertEqual(~self.R2, self.R2)
self.assertNotEqual(~self.H, self.H)
self.assertEqual(self.H * ~self.H, self.E)
def test_order(self):
self.assertEqual(self.E.order(), 1)
self.assertEqual(self.R1.order(), 2)
self.assertEqual(self.P1.order(), 2)
self.assertEqual(self.H.order(), 4)
def test_cmp(self):
self.assertTrue(self.E == Perm(data=[0, 1, 2]))
self.assertFalse(self.H == self.E)
self.assertTrue(self.H != self.H * self.H)
self.assertTrue(self.E != self.H)
def test_parity(self):
self.assertEqual(self.E.parity(), 0)
self.assertEqual(self.R1.parity(), 0)
self.assertEqual(self.P1.parity(), 1)
self.assertEqual(self.H.parity(), 1)
self.assertFalse(self.H.is_even())
self.assertTrue(self.H.is_odd())
self.assertEqual(self.H.sign(), -1)
def test_call(self):
self.assertEqual(Perm()(0)(2)()(1, 3), Perm()(1, 3))
self.assertEqual(Perm()(2, 3) * Perm()(1, 2), Perm()(1, 3, 2))
self.assertEqual(Perm()(2, 3)(1,2), Perm()(1, 3, 2))
self.assertEqual(Perm()(1, 2) * Perm()(2, 3), Perm()(1, 2, 3))
self.assertEqual(Perm()(1, 2)(2, 3), Perm()(1, 2, 3))
def test_getitem(self):
self.assertEqual(self.H[0], 1)
self.assertEqual(self.H[1], 3)
self.assertEqual(self.H[2], 0)
self.assertEqual(self.H[3], 2)
self.assertEqual(self.H[8], 8)
def test_pow(self):
self.assertEqual(pow(self.H,0), self.E)
self.assertEqual(pow(self.H,1), self.H)
self.assertEqual(pow(self.H,-1), ~self.H)
self.assertEqual(pow(self.H,4), self.E)
self.assertEqual(pow(self.H,3), ~self.H)
def test_min_max(self):
self.assertEqual(self.E.min(), 0) # konwencja
self.assertEqual(self.E.max(), 0) # konwencja
self.assertEqual(self.H.min(), 0)
self.assertEqual(self.H.max(), 3)
self.assertEqual(self.P1.min(), 1)
self.assertEqual(self.P1.max(), 2)
def test_list(self): # domyslnie wypisuje do perm.max()
self.assertEqual(self.E.list(), [0])
self.assertEqual(self.E.list(4), [0, 1, 2, 3])
self.assertEqual(self.P1.list(), [0, 2, 1])
# assertRaises(exception, callable, ...)
self.assertRaises(ValueError, lambda: self.H.list(2))
def test_support(self):
self.assertEqual(self.E.support(), [])
self.assertEqual(self.R1.support(), [0, 1, 2, 3])
self.assertEqual(self.P1.support(), [1, 2])
self.assertEqual(self.H.support(), [0, 1, 2, 3])
def test_commutator(self):
self.assertTrue(self.E.commutes_with(self.H))
self.assertTrue(self.R1.commutes_with(self.R2))
self.assertNotEqual(self.H.commutator(self.R1), self.E)
def test_lehmer(self):
size = 4
p = Perm()(0,3)(1,2) # [3, 2, 1, 0]
self.assertEqual(p.inversion_vector(size), [3, 2, 1, 0])
self.assertEqual(self.E.rank_lex(size), 0)
self.assertEqual(self.R1.rank_lex(size), 7)
self.assertEqual(self.P1.rank_lex(size), 2)
self.assertEqual(self.H.rank_lex(size), 10)
self.assertEqual(Perm.unrank_lex(size, 17), Perm()(0, 2, 1, 3))
def test_hash(self):
aset = set()
aset.add(self.E)
aset.add(self.E) # ignored
self.assertEqual(len(aset), 1)
aset.add(self.H)
aset.add(self.H) # ignored
self.assertEqual(len(aset), 2)
def tearDown(self): pass
def __init__(self):
"""Load up a Group instance."""
perm = Perm()
self[perm.label()] = perm
def setUp(self):
self.N = 4
# Make symmetric group S_N.
self.group1 = Group()
self.group1.insert(Perm()(0, 1))
self.group1.insert(Perm()(*range(self.N)))
