Exemple #1
0
class TestRubikGroup4Corner(unittest.TestCase):

    def setUp(self):
        self.N = 93
        self.group = Group()
        self.order_rubik4 = 707195371192426622240452051915172831683411968000000000
        X1 = Perm()(1,74,0,34)(2,70,92,38)(3,66,91,42)\
            (4,63,90,46)(47,50,62,59)(48,54,61,55)(49,58,60,51)(52,53,57,56)
        X2 = Perm()(5,75,89,33)(6,71,88,37)(7,67,87,41)(8,64,86,45)
        X3 = Perm()(9,76,85,32)(10,72,84,36)(11,68,83,40)(12,65,82,44)
        Y1 = Perm()(4,59,81,18)(8,55,85,22)(12,51,89,26)\
            (15,47,0,30)(31,34,46,43)(32,38,45,39)(33,42,44,35)(36,37,41,40)
        Y2 = Perm()(3,60,80,17)(7,56,84,21)(11,52,88,25)(14,48,92,29)
        Y3 = Perm()(2,61,79,16)(6,57,83,20)(10,53,87,24)(13,49,91,28)
        Z1 = Perm()(27,43,59,74)(28,44,60,75)(29,45,61,76)\
            (30,46,62,77)(78,81,0,90)(79,85,92,86)(80,89,91,82)(83,84,88,87)
        Z2 = Perm()(23,39,55,70)(24,40,56,71)(25,41,57,72)(26,42,58,73)
        Z3 = Perm()(19,35,51,66)(20,36,52,67)(21,37,53,68)(22,38,54,69)
        #self.generators = [X1, X2, X3, Y1, Y2, Y3, Z1, Z2, Z3]
        self.generators = [X1, X2, X3]   # order 64
        #self.generators = [Y1, Y2, Y3]   # order 64
        #self.generators = [Z1, Z2, Z3]   # order 64

    def test_insert_generators(self):
        for perm in self.generators:
            self.group.insert(perm)
        #self.assertEqual(self.group.order(), self.order_rubik4)
        self.assertEqual(self.group.order(), 64)

    def tearDown(self): pass
 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)))
Exemple #3
0
class TestSudoku4x4(unittest.TestCase):

    def setUp(self):
        self.N = 16
        self.group = Group()
        self.generators = []
        self.generators.append(
            Perm()(1,2)(5,6)(9,10)(13,14))
        self.generators.append(
            Perm()(3,4)(7,8)(11,12)(15,0))
        self.generators.append(
            Perm()(1,3)(2,4)(5,7)(6,8)(9,11)(10,12)(13,15)(14,0))
        self.generators.append(
            Perm()(1,5)(2,6)(3,7)(4,8))
        self.generators.append(
            Perm()(9,13)(10,14)(11,15)(12,0))
        self.generators.append(
            Perm()(1,9)(2,10)(3,11)(4,12)(5,13)(6,14)(7,15)(8,0))
        self.generators.append(
            Perm()(1,4,0,13)(2,8,15,9)(3,12,14,5)(6,7,11,10))

    def test_insert(self):
        for perm in self.generators:
            self.group.insert(perm)
        self.assertEqual(self.group.order(), 128)

    def tearDown(self): pass
Exemple #4
0
class TestRubikGroup2(unittest.TestCase):

    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 test_insert_generators(self):
        for perm in self.generators:
            #print "insert", perm
            #self.group.insert(perm)
            pass   # too slow and to big
        #self.assertEqual(self.group.order(), self.order_rubik2)

    def test_insert_face_turns(self):
        for perm in self.face_turns:
            #print "insert", perm
            #self.group.insert(perm)
            pass   # too slow and to big
        #self.assertEqual(self.group.order(), self.order_rubik2)

    def test_insert_quarter_turns(self):
        for perm in self.quarter_turns:
            #print "insert", perm
            #self.group.insert(perm)
            pass   # too slow and to big
        #self.assertEqual(self.group.order(), self.order_rubik2)

    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)
        #self.group.insert(Perm()(0, 9)(1, 10)(2, 11))
        #self.assertEqual(self.group.order(), 6 * 9 * 12)
        #self.group.insert(Perm()(0, 12)(1, 13)(2, 14))
        #self.assertEqual(self.group.order(), 6 * 9 * 12 * 15)
        #self.group.insert(Perm()(0, 15)(1, 16)(2, 17))
        #self.assertEqual(self.group.order(), 6 * 9 * 12 * 15 * 18)
        #self.group.insert(Perm()(0, 18)(1, 19)(2, 20))
        #self.assertEqual(self.group.order(), 6 * 9 * 12 * 15 * 18 * 21)

    def tearDown(self): pass
Exemple #5
0
class TestRubikGroup2(unittest.TestCase):
    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 test_insert_generators(self):
        for perm in self.generators:
            #self.group.insert(perm)
            pass  # too slow and too big
        #self.assertEqual(self.group.order(), self.order_rubik2)

    def test_insert_face_turns(self):
        for perm in self.face_turns:
            #self.group.insert(perm)
            pass  # too slow and too big
        #self.assertEqual(self.group.order(), self.order_rubik2)

    def test_insert_quarter_turns(self):
        for perm in self.quarter_turns:
            #self.group.insert(perm)
            pass  # too slow and too big
        #self.assertEqual(self.group.order(), self.order_rubik2)

    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)
        #self.group.insert(Perm()(0, 9)(1, 10)(2, 11))
        #self.assertEqual(self.group.order(), 6 * 9 * 12)
        #self.group.insert(Perm()(0, 12)(1, 13)(2, 14))
        #self.assertEqual(self.group.order(), 6 * 9 * 12 * 15)
        #self.group.insert(Perm()(0, 15)(1, 16)(2, 17))
        #self.assertEqual(self.group.order(), 6 * 9 * 12 * 15 * 18)
        #self.group.insert(Perm()(0, 18)(1, 19)(2, 20))
        #self.assertEqual(self.group.order(), 6 * 9 * 12 * 15 * 18 * 21)

    def tearDown(self):
        pass
 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_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_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_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)
Exemple #10
0
 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 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)
Exemple #12
0
 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)
Exemple #13
0
 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))
Exemple #14
0
 def setUp(self):
     self.N = 48
     self.group = Group()
     self.order_rubik3 = 43252003274489856000
     U1 = Perm()(1,3,8,6)(2,5,7,4)(9,33,25,17)(10,34,26,18)(11,35,27,19)
     L1 = Perm()(33,35,40,38)(34,37,39,36)(1,9,41,32)(4,12,44,29)(6,14,46,27)
     F1 = Perm()(9,11,16,14)(10,13,15,12)(6,17,43,40)(7,20,42,37)(8,22,41,35)
     R1 = Perm()(17,19,24,22)(18,21,23,20)(8,25,0,16)(5,28,45,13)(3,30,43,11)
     B1 = Perm()(25,27,32,30)(26,29,31,28)(3,33,46,24)(2,36,47,21)(1,38,0,19)
     D1 = Perm()(41,43,0,46)(42,45,47,44)(14,22,30,38)(15,23,31,39)(16,24,32,40)
     U2 = U1 * U1
     U3 = U1 * U2
     L2 = L1 * L1
     L3 = L1 * L2
     F2 = F1 * F1
     F3 = F1 * F2
     R2 = R1 * R1
     R3 = R1 * R2
     D2 = D1 * D1
     D3 = D1 * D2
     B2 = B1 * B1
     B3 = B1 * B2
     #self.generators = [U1, L1, F1, R1, B1, D1]
     self.generators = [U1, D1]   # order 16
     # cwiartki i polowki
     #self.face_turns = [U1, U2, U3, L1, L2, L3, F1, F2, F3, R1, R2, R3, D1, D2, D3, B1, B2, B3]
     self.face_turns = [L1, R1]   # order 16
     # tylko cwiartki
     #self.quarter_turns = [U1, U3, L1, L3, F1, F3, R1, R3, D1, D3, B1, B3]
     self.quarter_turns = [F1, B1]   # order 16
Exemple #15
0
 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))
Exemple #16
0
 def test_is_subgroup(self):
     self.group2 = Group()
     # Tworze grupe cykliczna.
     self.group2.insert(Perm()(*range(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))
Exemple #17
0
class TestCyclicGroup(unittest.TestCase):

    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 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_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 tearDown(self): pass
Exemple #18
0
class TestCyclicGroup(unittest.TestCase):
    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 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_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 tearDown(self):
        pass
Exemple #19
0
 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]])
Exemple #20
0
 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))
Exemple #21
0
 def test_sym_n(self):
     self.N = 4
     self.group = Group()
     order = 1
     for i in range(self.N-1):
         self.group.insert(Perm()(i, i+1))
         order *= (i+2)
         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)
Exemple #22
0
 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)
Exemple #23
0
 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)
Exemple #24
0
 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]
Exemple #25
0
 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)
class TestDihedralGroup(unittest.TestCase):
    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_insert(self):
        self.assertEqual(self.group.order(), 2 * self.N)
        self.assertTrue(Perm() in self.group)
        self.assertTrue(self.H in self.group)

    def tearDown(self):
        pass
Exemple #27
0
 def setUp(self):
     self.N = 51
     self.group = Group()
     self.order_rubik3 = 43252003274489856000
     X1 = Perm()(1,40,0,19)(2,37,50,22)(3,35,49,25)(26,28,34,32)(27,31,33,29)
     X2 = Perm()(4,41,48,18)(5,38,47,21)(6,36,46,24)
     Y1 = Perm()(3,32,45,10)(6,29,48,13)(8,26,0,16)(17,19,25,23)(18,22,24,20)
     Y2 = Perm()(2,33,44,9)(5,30,47,12)(7,27,50,15)
     Z1 = Perm()(14,23,32,40)(15,24,33,41)(16,25,34,42)(43,45,0,49)(44,48,50,46)
     Z2 = Perm()(11,20,29,37)(12,21,30,38)(13,22,31,39)
     #self.generators = [X1, X2, Y1, Y2, Z1, Z2]
     #self.generators = [X1, X2]   # order 16
     #self.generators = [Y1, Y2]   # order 16
     self.generators = [Z1, Z2]   # order 16
Exemple #28
0
class TestRubikGroup3Corner(unittest.TestCase):

    def setUp(self):
        self.N = 51
        self.group = Group()
        self.order_rubik3 = 43252003274489856000
        X1 = Perm()(1,40,0,19)(2,37,50,22)(3,35,49,25)(26,28,34,32)(27,31,33,29)
        X2 = Perm()(4,41,48,18)(5,38,47,21)(6,36,46,24)
        Y1 = Perm()(3,32,45,10)(6,29,48,13)(8,26,0,16)(17,19,25,23)(18,22,24,20)
        Y2 = Perm()(2,33,44,9)(5,30,47,12)(7,27,50,15)
        Z1 = Perm()(14,23,32,40)(15,24,33,41)(16,25,34,42)(43,45,0,49)(44,48,50,46)
        Z2 = Perm()(11,20,29,37)(12,21,30,38)(13,22,31,39)
        #self.generators = [X1, X2, Y1, Y2, Z1, Z2]
        #self.generators = [X1, X2]   # order 16
        #self.generators = [Y1, Y2]   # order 16
        self.generators = [Z1, Z2]   # order 16

    def test_insert_generators(self):
        for perm in self.generators:
            self.group.insert(perm)
        #self.assertEqual(self.group.order(), self.order_rubik3)
        self.assertEqual(self.group.order(), 16)

    def tearDown(self): pass
Exemple #29
0
 def test_sym_5(self):
     self.N = 5
     self.group = Group()
     self.assertEqual(self.group.order(), 1)
     self.group.insert(Perm()(0, 1))
     self.assertEqual(self.group.order(), 2)
     self.group.insert(Perm()(1, 2))
     self.assertEqual(self.group.order(), 6)
     self.group.insert(Perm()(2, 3))
     self.assertEqual(self.group.order(), 24)
     self.group.insert(Perm()(3, 4))
     self.assertEqual(self.group.order(), 120)
     self.assertTrue(Perm()(*range(self.N)) in self.group)
     self.assertTrue(self.group.is_transitive(points=range(self.N)))
     self.assertEqual(len(self.group.orbits(range(self.N))), 1)
Exemple #30
0
 def setUp(self):
     self.N = 16
     self.group = Group()
     self.generators = []
     self.generators.append(
         Perm()(1,2)(5,6)(9,10)(13,14))
     self.generators.append(
         Perm()(3,4)(7,8)(11,12)(15,0))
     self.generators.append(
         Perm()(1,3)(2,4)(5,7)(6,8)(9,11)(10,12)(13,15)(14,0))
     self.generators.append(
         Perm()(1,5)(2,6)(3,7)(4,8))
     self.generators.append(
         Perm()(9,13)(10,14)(11,15)(12,0))
     self.generators.append(
         Perm()(1,9)(2,10)(3,11)(4,12)(5,13)(6,14)(7,15)(8,0))
     self.generators.append(
         Perm()(1,4,0,13)(2,8,15,9)(3,12,14,5)(6,7,11,10))
Exemple #31
0
 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]
Exemple #32
0
class TestCyclicGroup(unittest.TestCase):

    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 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)
        self.assertFalse(Perm()(*range(self.N)) in self.group)
        self.assertFalse(self.group.is_transitive(points=range(self.N)))
        self.assertEqual(len(self.group.orbits(range(self.N))), 2)

    def tearDown(self): pass
 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)))
Exemple #34
0
 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)))
Exemple #35
0
 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)
Exemple #36
0
class TestAlternatingGroup(unittest.TestCase):
    def setUp(self):
        pass

    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 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 tearDown(self):
        pass
Exemple #37
0
 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 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)))
 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))
Exemple #40
0
class TestSymmetricGroup(unittest.TestCase):

    def setUp(self): pass

    def test_sym_5(self):
        self.N = 5
        self.group = Group()
        self.assertEqual(self.group.order(), 1)
        self.group.insert(Perm()(0, 1))
        self.assertEqual(self.group.order(), 2)
        self.group.insert(Perm()(1, 2))
        self.assertEqual(self.group.order(), 6)
        self.group.insert(Perm()(2, 3))
        self.assertEqual(self.group.order(), 24)
        self.group.insert(Perm()(3, 4))
        self.assertEqual(self.group.order(), 120)
        self.assertTrue(Perm()(*range(self.N)) in self.group)
        self.assertTrue(self.group.is_transitive(points=range(self.N)))
        self.assertEqual(len(self.group.orbits(range(self.N))), 1)

    def test_sym_n(self):
        self.N = 4
        self.group = Group()
        order = 1
        for i in range(self.N-1):
            self.group.insert(Perm()(i, i+1))
            order *= (i+2)
            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 tearDown(self): pass
Exemple #41
0
 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 TestGroupOrbits(unittest.TestCase):
    def setUp(self):
        pass

    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_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_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)))

    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 tearDown(self):
        pass
Exemple #43
0
class TestGroupOrbits(unittest.TestCase):

    def setUp(self): pass

    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_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_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)))

    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 tearDown(self): pass
 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())
Exemple #45
0
 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)))
Exemple #46
0
class TestSubgroup(unittest.TestCase):

    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 test_subgroup_search(self):
        self.assertEqual(self.group1.order(), 24)
        # Dopuszczam permutacje parzyste - grupa alternujaca.
        self.group2 = self.group1.subgroup_search(lambda x: x.is_even())
        self.assertEqual(self.group2.order(), 12)
        self.assertTrue(self.group2.is_transitive(points=range(self.N)))
        #print self.group2

    def test_stabilizer(self):
        self.group2 = self.group1.stabilizer(3)
        self.assertEqual(self.group2.order(), 6)
        #print self.group2

    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 test_is_subgroup(self):
        self.group2 = Group()
        # Tworze grupe cykliczna.
        self.group2.insert(Perm()(*range(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 tearDown(self): pass
class TestSubgroup(unittest.TestCase):
    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 test_subgroup_search(self):
        self.assertEqual(self.group1.order(), 24)
        # Dopuszczam permutacje parzyste - grupa alternujaca.
        self.group2 = self.group1.subgroup_search(lambda x: x.is_even())
        self.assertEqual(self.group2.order(), 12)
        self.assertTrue(self.group2.is_transitive(points=range(self.N)))
        #print self.group2

    def test_stabilizer(self):
        self.group2 = self.group1.stabilizer(3)
        self.assertEqual(self.group2.order(), 6)
        #print self.group2

    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 test_normalizer(self):
        pass

    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_derived_subgroup(self):
        pass

    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_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 tearDown(self):
        pass
Exemple #48
0
class TestAlternatingGroup(unittest.TestCase):

    def setUp(self): pass

    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 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 tearDown(self): pass