First commit

Cryptotools/Groups/cyclic.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+
+from Cryptotools.Groups.group import Group
+
+
+class Cyclic(Group):
+    """
+        This object contain a list of the Group for a cyclic group. This class find all generator of the group.
+        This class is inherited from Group object
+
+        Attributes:
+            G (list): list of all elements in the group
+            n (Integer): it's the value where the group has been generated
+            operation (Function): it's the operation generating the group
+            generators (list): contain all generators of the group 
+            generatorChecked (boolean): Check if generators has been found
+    """
+    def __init__(self, G:list, n, ope):
+        super().__init__(n, G, ope) # Call the Group's constructor
+        self._G = G
+        self._n = n
+        self._operation = ope
+        self._generators = list()
+        self._generatorChecked = False
+
+    def generator(self):
+        """
+            This function find all generators in the group G
+        """
+
+        index = 1
+        G = sorted(self._g)
+        for g in range(2, self._n):
+            z = list()
+            for entry in range(1, self._n):
+                res = self._operation(g, index, self._n)
+                if res not in z:
+                    z.append(res)
+                    index = index + 1
+
+            # We check if that match with G
+            # If yes, we find a generator
+            if sorted(z) == G:
+                self._generators.append(g)
+        self._generatorChecked = True
+
+    def getPrimitiveRoot(self):
+        """
+            This function return the primitive root modulo of n
+
+            Returns:
+                Return the primitive root of the group. None if no primitive has been found
+        """
+
+        index = 1
+        G = sorted(self._g)
+        for g in range(2, self._n):
+            z = list()
+            for entry in range(1, self._n):
+                res = self._operation(g, index, self._n)
+                if res not in z:
+                    z.append(res)
+                    index += 1
+
+            # If the group is the same has G, we found a generator
+            if sorted(z) == G:
+                return g
+        return None
+
+    def getGenerators(self) -> list:
+        """
+            This function return all generators of that group
+            
+            Returns:
+                Return the list of generators found. The function generators() must be called before to call this function
+        """
+        if not self._generatorChecked:
+            self.generator()
+            self._generatorChecked = True
+        return self._generators
+
+    def isCyclic(self) -> bool:
+        """
+            Check if the group is a cyclic group, means we have at least one generator
+
+            Returns:
+                REturn a boolean, False if the group is not Cyclic otherwise return True
+        """
+        if len(self.getGenerators()) == 0:
+            return False
+        return True