Added Group.find_isomorphism, Group.generators, Group.Dn, and fixed Function hashing bug.

Author: naftaliharris

absalg/Function.py

@@ -30,14 +30,28 @@ def __call__(self, elem):
         return self.function(elem)
 
     def __hash__(self):
-        return hash(self.domain) ^ hash(self.codomain) ^ hash(self.function)
+        """Returns the hash of self"""
+
+        # Need to be a little careful, since self.domain and self.codomain are
+        # often the same, and we don't want to cancel out their hashes by xoring
+        # them against each other.
+        # 
+        # Also, functions we consider equal, like lambda x: x + 1, and 
+        # def jim(x): return x + 1, have different hashes, so we can't include 
+        # the hash of self.function.
+        #
+        # Finally, we should make sure that if you switch the domain and 
+        # codomain, the hash will (usually) change, so you can't just add or
+        # multiply the hashes together.
+
+        return hash(self.domain) + 2 * hash(self.codomain)
 
     def __eq__(self, other):
         if not isinstance(other, Function):
             return False
 
         return id(self) == id(other) or ( \
-               isinstance(other, Function) and self.domain == other.domain and \
+               self.domain == other.domain and \
                self.codomain == other.codomain and \
                all(self(elem) == other(elem) for elem in self.domain) )
 

absalg/Group.py

@@ -160,6 +160,9 @@ def __iter__(self):
         for g in self.group_elems:
             if g != self.e: yield g
 
+    def __contains__(self, item):
+        return item in self.group_elems
+
     def __hash__(self):
         return hash(self.Set) ^ hash(self.bin_op)
 
@@ -258,15 +261,22 @@ def __mul__(self, other):
     def generate(self, elems):
         """
         Returns the subgroup of self generated by GroupElems elems
+
+        If any of the items aren't already GroupElems, we will try to convert
+        them to GroupElems before continuing.
         
         elems must be iterable
         """
-        if not Set(elems) <= self.group_elems:
+
+        elems = Set(g if isinstance(g, GroupElem) else GroupElem(g, self) \
+                    for g in elems)
+
+        if not elems <= self.group_elems:
             raise ValueError("elems must be a subset of self.group_elems")
         if len(elems) == 0:
             raise ValueError("elems must have at least one element")
 
-        oldG = Set(elems)
+        oldG = elems
         while True:
             newG = oldG | Set(a * b for a in oldG for b in oldG)
             if oldG == newG: break
@@ -288,6 +298,80 @@ def subgroups(self):
 
         return old_sgs
 
+    def generators(self):
+        """
+        Returns a list of GroupElems that generate self, with length
+        at most log_2(len(self)) + 1
+        """
+
+        result = [self.e.elem]
+        H = self.generate(result)
+
+        while len(H) < len(self):
+            result.append((self.Set - H.Set).pick())
+            H = self.generate(result)
+
+        # The identity is always a redundant generator in nontrivial Groups
+        if len(self) != 1:
+            result = result[1:]
+
+        return [GroupElem(g, self) for g in result]
+
+    def find_isomorphism(self, other):
+        """
+        Returns an isomorphic GroupHomomorphism between self and other,
+        or None if self and other are not isomorphic
+
+        Uses Tarjan's algorithm, running in O(n^(log n + O(1))) time, but
+        runs a lot faster than that if the group has a small generating set.
+        """
+        if not isinstance(other, Group):
+            raise TypeError("other must be a Group")
+
+        if len(self) != len(other) or self.is_abelian() != other.is_abelian():
+            return None
+
+        # Try to match the generators of self with some subset of other
+        A = self.generators()
+        for B in itertools.permutations(other, len(A)):
+
+            func = dict(itertools.izip(A, B)) # the mapping
+            counterexample = False
+            while not counterexample:
+
+                # Loop through the mapped elements so far, trying to extend the
+                # mapping or else find a counterexample
+                noobs = {}
+                for g, h in itertools.product(func, func):
+                    if g * h in func:
+                        if func[g] * func[h] != func[g * h]:
+                            counterexample = True
+                            break
+                    else: 
+                        noobs[g * h] = func[g] * func[h]
+
+                # If we've mapped all the elements of self, then it's a
+                # homomorphism provided we haven't seen any counterexamples.
+                if len(func) == len(self): 
+                    break
+
+                # Make sure there aren't any collisions before updating
+                imagelen = len(set(noobs.values()) | set(func.values()))
+                if imagelen != len(noobs) + len(func):
+                    counterexample = True
+                func.update(noobs)
+
+            if not counterexample:
+                return GroupHomomorphism(self.group_elems, other.group_elems, \
+                                         lambda x: func[x])
+
+        return None
+
+    def is_isomorphic(self, other):
+        """Checks if self and other are isomorphic"""
+        return bool(self.find_isomorphism(other))
+
+
 class GroupHomomorphism(Function):
     """
     The definition of a Group Homomorphism
@@ -342,13 +426,32 @@ def is_isomorphism(self):
 
 
 def Zn(n):
-    """ Returns the cylic group of order n"""
+    """Returns the cylic group of order n"""
     G = Set(range(n))
     bin_op = Function(G * G, G, lambda x: (x[0] + x[1]) % n)
     return Group(G, bin_op)
 
 def Sn(n):
-    """ Returns the symmetric group of order n! """
+    """Returns the symmetric group of order n! """
     G = Set(g for g in itertools.permutations(range(n)))
     bin_op = Function(G * G, G, lambda x: tuple(x[0][j] for j in x[1]))
     return Group(G, bin_op)
+
+def Dn(n):
+    """Returns the dihedral group of order 2n """
+    G = Set("%s%d" % (l, x) for l in "RS" for x in xrange(n))
+    def multiply_symmetries(x):
+        l1, l2 = x[0][0], x[1][0]
+        x1, x2 = int(x[0][1:]), int(x[1][1:])
+        if l1 == "R":
+            if l2 == "R":
+                return "R%d" % ((x1 + x2) % n)
+            else:
+                return "S%d" % ((x1 + x2) % n)
+        else:
+            if l2 == "R":
+                return "S%d" % ((x1 - x2) % n)
+            else:
+                return "R%d" % ((x1 - x2) % n)
+    return Group(G, Function(G * G, G, multiply_symmetries))
+

test/group_test.py

@@ -70,6 +70,7 @@ def test_group_elem(self):
         self.assertEquals(b + c, a)
         self.assertEquals(a + c, b)
         for g in V:
+            self.assertTrue(g in V)
             self.assertEquals(g, g)
             self.assertEquals(e * g, g)
             self.assertEquals(g * e, g)
@@ -107,10 +108,35 @@ def test_group_elem(self):
                     self.assertEquals(h * g, GroupElem(h.elem, G) * g)
                     self.assertEquals(g * h, g * GroupElem(h.elem, G))
 
-    def test_group_homomorphism(self):
-        Z2, Z3 = Zn(2), Zn(3)
-        Z32 = Z3 * Z2
-        
+    def test_generators(self):
+        for G in [Zn(1), Zn(2), Zn(5), Zn(8), Sn(1), Sn(2), Sn(3), \
+                  Dn(1), Dn(2), Dn(3), Dn(4)]:
+            self.assertEquals(G, G.generate(G.generators()))
+            self.assertEquals(G, G.generate(g.elem for g in G.generators()))
+
+    def test_find_isomorphism(self):
+        f = Dn(2).find_isomorphism(Zn(2) * Zn(2))
+        self.assertTrue(f is not None)
+        self.assertTrue(f.is_isomorphism())
+        self.assertEquals(f.kernel(), Dn(2).generate([Dn(2).e]))
+        self.assertEquals(f.image(), Zn(2) * Zn(2))
+
+        self.assertFalse(Dn(12).is_isomorphic(Sn(4)))
+        self.assertFalse(Sn(3).is_isomorphic(Zn(6)))
+        self.assertFalse(Sn(3).is_isomorphic(Zn(4)))
+
+        for G in [Zn(1), Zn(2), Zn(5), Sn(1), Sn(3), Dn(1), Dn(4)]:
+            self.assertTrue(G.is_isomorphic(G))
+            f = G.find_isomorphism(G)
+            self.assertTrue(f is not None)
+            self.assertTrue(f.is_isomorphism())
+            self.assertEquals(f.kernel(), G.generate([G.e]))
+            self.assertEquals(f.image(), G)
+
+        self.assertTrue(Zn(1).is_isomorphic(Sn(1)))
+        self.assertTrue(Zn(2).is_isomorphic(Sn(2)))
+        self.assertTrue(Zn(2).is_isomorphic(Dn(1)))
+
 
 if __name__ == "__main__":
     unittest.main()