Ticket #6679: trac_6679.patch

sage/graphs/graph.py

@@ -4682 +4682 @@
             vertices = [v for v in vertices if vertex_property(v)]
 
         if algorithm is not None and algorithm not in ("delete", "add"):
-            raise ValueError, 'algorithm should be None, "delete", or "add"'
+            raise ValueError('algorithm should be None, "delete", or "add"')
             
         if inplace or len(vertices)>0.05*self.order() or algorithm=="delete":
             return self._subgraph_by_deleting(vertices=vertices, edges=edges, 
@@ -8129 +8129 @@
                 try:
                     hash(perm[v])
                 except TypeError:
-                    raise ValueError, "perm dictionary must be of the format {a:a1, b:b1, ...} where a,b,... are vertices and a1,b1,... are hashable"
+                    raise ValueError("perm dictionary must be of the format {a:a1, b:b1, ...} where a,b,... are vertices and a1,b1,... are hashable")
         self._backend.relabel(perm, self._directed)
 
         attributes_to_update = ('_pos', '_assoc', '_embedding')
@@ -9402 +9402 @@
             if weighted   is None: weighted   = False
             if multiedges is None: multiedges = False
             if not isinstance(data, str):
-                raise ValueError, 'If input format is graph6, then data must be a string.'
+                raise ValueError('If input format is graph6, then data must be a string.')
             n = data.find('\n')
             if n == -1:
                 n = len(data)
@@ -9745 +9745 @@
         """
         n = self.order()
         if n > 262143:
-            raise ValueError, 'graph6 format supports graphs on 0 to 262143 vertices only.'
+            raise ValueError('graph6 format supports graphs on 0 to 262143 vertices only.')
         elif self.has_loops() or self.has_multiple_edges():
-            raise ValueError, 'graph6 format supports only simple graphs (no loops, no multiple edges)'
+            raise ValueError('graph6 format supports only simple graphs (no loops, no multiple edges)')
         else:
             return graph_fast.N(n) + graph_fast.R(self._bit_vector())
 
@@ -9779 +9779 @@
         if n == 0:
             return ':?'
         if n > 262143:
-            raise ValueError, 'sparse6 format supports graphs on 0 to 262143 vertices only.'
+            raise ValueError('sparse6 format supports graphs on 0 to 262143 vertices only.')
         else:
             vertices = self.vertices()
             n = len(vertices)
@@ -10021 +10021 @@
         from sage.graphs.chrompoly import chromatic_polynomial
         return chromatic_polynomial(self)
 
-    def chromatic_number(self):
+    def chromatic_number(self, algorithm="DLX"):
         """
         Returns the minimal number of colors needed to color the vertices
-        of the graph G.
-        
+        of the graph `G`.
+
+        INPUT:
+
+        - ``algorithm`` -- Selects an algorithm
+
+            - If ``algorithm = "DLX"`` ( default ), the chromatic number is computed
+              through the dancing link algorithm.
+
+              Computing the chromatic number through the Dancing Link Algorithm is a
+              very slow method, as it computes ALL the possible colorings to check
+              that one exists.
+
+            - If ``algorithm = "CP"``, the chromatic number is computed
+              through the coefficients of the Chromatic Polynomial.
+
+              Computing the chromatic number through the chromatic polynomial is a
+              very slow method, which will only be useful for small graphs.
+
+            - If ``algorithm = "MILP"``, the chromatic number
+              is computed through a Mixed Integer Linear Program.
+
+              Computing the chromatic number through a Mixed Integer Linear
+              Program may require to install an optional Sage package like GLPK
+              or Coin-OR's CBC.
+
+        For more functions related to graph coloring, see 
+        the ``sage.graphs.graph_coloring`` module.
+
         EXAMPLES::
         
             sage: G = Graph({0:[1,2,3],1:[2]})
-            sage: G.chromatic_number()
-            3
-        """
-        f = self.chromatic_polynomial()
-        i = 0
-        while f(i) == 0:
-            i += 1
-        return i
-
-    def coloring(self, hex_colors=False):
-        """
-        Returns the first (optimal) coloring found.
-        
-        INPUT::
-        
-            hex_colors -- if True, return a dict which can
-                          easily be used for plotting
+            sage: G.chromatic_number(algorithm="DLX")
+            3
+            sage: G.chromatic_number(algorithm="MILP") # optional - requires GLPK or CBC
+            3
+            sage: G.chromatic_number(algorithm="CP")
+            3
+
+        TESTS::
+
+            sage: G = Graph({0:[1,2,3],1:[2]})
+            sage: G.chromatic_number(algorithm="foo")
+            Traceback (most recent call last):
+            ...
+            ValueError: The `algorithm` variable must be set to either `DLX`, `MILP` or `CP`.
+        """
+        if algorithm == "DLX":
+            from sage.graphs.graph_coloring import chromatic_number
+            return chromatic_number(self)
+
+        elif algorithm == "MILP":
+            from sage.graphs.graph_coloring import vertex_coloring
+            return vertex_coloring(self, value_only=True)
+
+        elif algorithm == "CP":
+            f = self.chromatic_polynomial()
+            i = 0
+            while f(i) == 0:
+                i += 1
+            return i
+        else:
+            raise ValueError("The `algorithm` variable must be set to either `DLX`, `MILP` or `CP`.")
+
+    def coloring(self, algorithm="DLX", hex_colors=False):
+        """
+        Returns the first (optimal) proper vertex-coloring found.
+        
+        INPUT:
+        
+        - If ``algorithm = "DLX"`` (default), the chromatic number is computed
+          through the dancing link algorithm.
+
+        - If ``algorithm = "MILP"``, the chromatic number
+          is computed through a Mixed Integer Linear Program.
+
+          Computing the chromatic number through a Mixed Integer Linear
+          Program may require to install an optional Sage package like GLPK
+          or Coin-OR's CBC.
+
+        - ``hex_colors`` -- if ``True``, return a dict which can
+           easily be used for plotting
+
+        For more functions related to graph coloring, see 
+        the ``sage.graphs.graph_coloring`` module.
         
         EXAMPLES::
         
             sage: G = Graph("Fooba")
 
-            sage: P = G.coloring(); P
+            sage: P = G.coloring(algorithm="MILP"); P  # optional - requires GLPK or CBC
+            [[2, 1, 3], [0, 6, 5], [4]]
+            sage: P = G.coloring(algorithm="DLX"); P
             [[1, 2, 3], [0, 5, 6], [4]]
             sage: G.plot(partition=P)
 
-            sage: H = G.coloring(hex_colors=True)
+            sage: H = G.coloring(hex_colors=True,algorithm="MILP") # optional - requires GLPK or CBC
+            sage: for c in sorted(H.keys()):                       # optional - requires GLPK or CBC
+            ...    print c, H[c]                                   # optional - requires GLPK or CBC
+            #0000ff [4]
+            #00ff00 [0, 6, 5]
+            #ff0000 [2, 1, 3]
+            sage: H = G.coloring(hex_colors=True, algorithm="DLX")
             sage: for c in sorted(H.keys()):
             ...    print c, H[c]
             #0000ff [4]
@@ -10063 +10134 @@
             #ff0000 [0, 5, 6]
             sage: G.plot(vertex_colors=H)
 
-        """
-        from sage.graphs.graph_coloring import all_graph_colorings
-        for C in all_graph_colorings(self, self.chromatic_number()):
-            if hex_colors:
-                return C
-            else:
-                return C.values()
-
+        TESTS::
+
+            sage: G.coloring(algorithm="foo")
+            Traceback (most recent call last):
+            ...
+            ValueError: The `algorithm` variable must be set to either `DLX` or `MILP`.
+        """
+        if algorithm == "MILP":
+            from sage.graphs.graph_coloring import vertex_coloring
+            return vertex_coloring(self,hex_colors=hex_colors)
+        elif algorithm == "DLX":
+            from sage.graphs.graph_coloring import first_coloring
+            return first_coloring(self, hex_colors=hex_colors)
+        else:
+            raise ValueError("The `algorithm` variable must be set to either `DLX` or `MILP`.")
+    
     ### Centrality
-    
+
     def centrality_betweenness(self, normalized=True):
         r"""
         Returns the betweenness centrality (fraction of number of shortest
@@ -10759 +10838 @@
 
         """
         if self.is_directed() or self.has_loops() or self.has_multiple_edges():
-            raise ValueError, "Self must be an undirected simple graph to have a clique_complex."
+            raise ValueError("Self must be an undirected simple graph to have a clique_complex.")
         import sage.homology.simplicial_complex
         C = sage.homology.simplicial_complex.SimplicialComplex(self.vertices(),self.cliques_maximal(),maximality_check=True)
         C._graph = self
@@ -11252 +11331 @@
             if weighted   is None: weighted   = False
             if multiedges is None: multiedges = False
             if not isinstance(data, str):
-                raise ValueError, 'If input format is dig6, then data must be a string.'
+                raise ValueError('If input format is dig6, then data must be a string.')
             n = data.find('\n')
             if n == -1:
                 n = len(data)
@@ -11524 +11603 @@
         """
         n = self.order()
         if n > 262143:
-            raise ValueError, 'dig6 format supports graphs on 0 to 262143 vertices only.'
+            raise ValueError('dig6 format supports graphs on 0 to 262143 vertices only.')
         elif self.has_multiple_edges():
-            raise ValueError, 'dig6 format does not support multiple edges.'
+            raise ValueError('dig6 format does not support multiple edges.')
         else:
             return graph_fast.N(n) + graph_fast.R(self._bit_vector())
 

sage/graphs/graph_coloring.py

@@ -4 +4 @@
 AUTHORS:
     -- Tom Boothby   (2008-02-21): Initial version
     -- Carlo Hamalainen (2009-03-28): minor change: switch to C++ DLX solver
+    -- Nathann Cohen (2009-10-24): Coloring methods using Linear Programming
 """
 
 #*****************************************************************************
@@ -141 +142 @@
     except RuntimeError:
         raise RuntimeError, "Too much recursion!  Graph coloring failed."
 
-def first_coloring(G,n=0):
+def first_coloring(G,n=0, hex_colors=True):
     """
-    Given a graph, and optionally a natural number n, returns
-    the first coloring we find with at least n colors.
+    Given a graph, and optionally a natural number `n`, returns
+    the first coloring we find with at least `n` colors.
+
+    INPUT:
+
+    - ``hex_colors`` -- When set to ``True`` ( it is ``False`` by default ),
+       the partition returned is a dictionary whose keys are colors and whose
+       values are the color classes ( ideal to be plotted )
+    -  ``n`` -- The minimal number of colors to be tried.
+
 
     EXAMPLES:
         sage: from sage.graphs.graph_coloring import first_coloring
@@ -155 +164 @@
     o = G.order()
     for m in range(n,o+1):
         for C in all_graph_colorings(G,m):
-            return C
+            if hex_colors:
+                return C
+            else:
+                return C.values()
 
 def number_of_n_colorings(G,n):
     """
@@ -228 +240 @@
         for C in all_graph_colorings(G,n):
             return n    
 
+
+def vertex_coloring(self,k=None,value_only=False,hex_colors=False,log=0):
+    """
+    Computes the chromatic number of a graph, or tests its `k`-colorability
+    ( cf. http://en.wikipedia.org/wiki/Graph_coloring )
+    
+    INPUT:
+
+    - ``value_only`` ( boolean )--
+        - When set to ``True``, only the chromatic number is returned
+        - When set to ``False`` (default), a partition of the vertex set into
+          independant sets is returned is possible
+
+    - ``k`` ( an integer ) -- Tests whether the graph is `k`-colorable.
+      The function returns a partition of the vertex set in `k` 
+      independent sets if possible and ``False`` otherwise.
+
+    - ``hex_colors`` -- When set to ``True`` ( it is ``False`` by default ),
+       the partition returned is a dictionary whose keys are colors and whose
+       values are the color classes ( ideal to be plotted )
+
+    - ``log`` ( integer ) -- As vertex-coloring is a `NP`-complete problem,
+      its solving may take some time depending on the graph. Use ``log`` to 
+      define the level of verbosity you want from the linear program solver.
+                       
+      By default ``log=0``, meaning that there will be no message printed by the solver.
+
+    OUTPUT :
+    
+    - If ``k=None`` and ``value_only=None``:
+      Returns a partition of the vertex set into the minimum possible of independent sets
+
+    - If ``k=None`` and ``value_only=True``:
+      Returns the chromatic number
+              
+    - If ``k`` is set and ``value_only=None``:
+      Returns False if the graph is not `k`-colorable, and a partition of the
+      vertex set into `k` independent sets otherwise
+
+    - If ``k`` is set and ``value_only=True``:
+      Test whether the graph is `k`-colorable and returns ``True`` or ``False`` accordingly
+              
+
+    EXAMPLE::
+    
+       sage: from sage.graphs.graph_coloring import vertex_coloring
+       sage: g=graphs.PetersenGraph()
+       sage: vertex_coloring(g, value_only=True) # optional - requires GLPK or CBC
+       3
+       
+    """
+    from sage.numerical.mip import MixedIntegerLinearProgram
+    from sage.plot.colors import rainbow
+    g=self
+
+    # If k==None, tries to find an optimal coloring
+    if k==None:
+
+        # No need to start a linear program if the graph is an independent set or bipartite
+        # 
+        # - Independent set
+        if g.size()==0:
+            if value_only:
+                return 1
+            elif hex_colors:
+                return dict(zip(rainbow(1),g.vertices()))
+            else:
+                return g.vertices()
+
+        # - Bipartite set
+        if g.is_bipartite():
+            if value_only==True:
+                return 2
+            if hex_colors:
+                return dict(zip(rainbow(2),g.bipartite_sets()))
+            else:
+                return g.bipartite_sets()
+
+        # - No need to try any k smaller than the maximum clique in the graph
+        # - max, because the graph could be triangle-free
+
+        k=max(3, g.clique_number() )
+
+        while True:
+            # tries to color the graph, increasing k each time it fails.
+            tmp=vertex_coloring(g, k=k, value_only=value_only,hex_colors=hex_colors,log=log)
+            if tmp!=False:
+                if value_only:
+                    return k
+                else:
+                    return tmp
+            k=k+1
+    else:
+        # Is the graph empty ?
+
+        # If the graph is empty, something should be returned..
+        # This is not so stupid, as the graph could be emptied
+        # by the test of degeneracy
+        if g.order()==0:
+            if value_only==True:
+                return True
+            elif hex_colors==True:
+                return dict([(color,[]) for color in rainbow(k)])
+            else:
+                return [[] for i in range(k)]
+
+        # Is the graph connected ?
+
+        # This is not so stupid, as the graph could be disconnected
+        # by the test of degeneracy ( as previously )
+
+        if g.is_connected()==False:
+            if value_only==True:
+                for component in g.connected_components():
+                    if vertex_coloring(g.subgraph(component),k=k,value_only=value_only,hex_colors=hex_colors,log=log)==False:
+                        return False
+                return True
+
+            colorings=[]
+            for component in g.connected_components():
+                tmp=vertex_coloring(g.subgraph(component),k=k,value_only=value_only,hex_colors=False,log=log)
+                if tmp==False:
+                    return False
+                colorings.append(tmp)
+            value=[[] for color in range(k)]
+            for color in range(k):
+                for component in colorings:
+                    value[color].extend(component[color])
+
+            if hex_colors:
+                return dict(zip(rainbow(k),value))
+            else:
+                return value
+                    
+        # Degeneracy
+
+        # Vertices whose degree is less than k are of no importance in the coloring
+
+        if min(g.degree())<k:
+            vertices=set(g.vertices())
+            deg=[]
+            tmp=[v for v in vertices if g.degree(v)<k]
+            while len(tmp)>0:
+                v=tmp.pop(0)
+                neighbors=list(set(g.neighbors(v)) & vertices)
+                if v in vertices and len(neighbors)<k:
+                    vertices.remove(v)
+                    tmp.extend(neighbors)
+                    deg.append(v)
+
+            if value_only==True:
+                return vertex_coloring(g.subgraph(list(vertices)),k=k,value_only=value_only,hex_colors=hex_colors,log=log)
+
+            value=vertex_coloring(g.subgraph(list(vertices)),k=k,value_only=value_only,hex_colors=False,log=log)
+            if value==False:
+                return False
+            while len(deg)>0:
+                for classe in value:
+                    if len(list(set(classe) & set(g.neighbors(deg[-1]))))==0:
+                        classe.append(deg[-1])
+                        deg.pop(-1)
+                        break
+            if hex_colors:
+                return dict(zip(rainbow(k),value))
+            else:
+                return value
+         
+        
+        p=MixedIntegerLinearProgram(maximization=True)
+        color=p.new_variable(dim=2)
+
+        # a vertex has exactly one color
+        [p.add_constraint(sum([color[v][i] for i in range(k)]),min=1,max=1) for v in g.vertices()]
+
+        # Adjacent vertices have different colors
+        [p.add_constraint(color[u][i]+color[v][i],max=1) for (u,v) in g.edge_iterator(labels=None) for i in range(k)]
+
+        # Anything is good as an objective value as long as it is satisfiable
+        p.add_constraint(color[g.vertex_iterator().next()][0], max=1, min=1)
+        p.set_objective(color[g.vertex_iterator().next()][0])
+
+        p.set_binary(color)
+        from sage.numerical.mip import MIPSolverException
+
+        try:
+            if value_only==True:
+                p.solve(objective_only=True,log=log)
+                return True
+            else:
+                chi=p.solve(log=log)
+        except MIPSolverException:
+            return False
+
+        color=p.get_values(color)
+
+        # builds the color classes
+        classes=[[] for i in range(k)]
+        [classes[i].append(v) for i in range(k) for v in g.vertices() if color[v][i]==1]
+
+        if hex_colors:
+            return dict(zip(rainbow(len(classes)),classes))
+        else:
+            return classes
+
+def edge_coloring(self,value_only=False,vizing=False,hex_colors=False, log=0):
+    """
+    Properly colors the edges of a graph.
+    ( cf. http://en.wikipedia.org/wiki/Edge_coloring )
+    
+    INPUT:
+
+    - ``value_only`` (boolean) --
+
+        - When set to ``True``, only the chromatic index is returned
+        - When set to ``False`` (default), a partition of the edge set into
+          matchings is returned is possible
+
+    - ``vizing`` (boolean) --
+        - When set to ``True``, tries to find a `\Delta+1`-edge-coloring ( where
+          `\Delta` is equal to the maximum degree in the graph )
+
+        - When set to ``False``, tries to find a `\Delta`-edge-coloring ( where
+          `\Delta` is equal to the maximum degree in the graph ). If impossible,
+          tries to find and returns a `\Delta+1`-edge-coloring
+                       
+              --- Implies ``value_only = False`` ---
+
+    - ``hex_colors`` (boolean) --
+
+      When set to ``True`` ( it is ``False`` by default ), the partition returned
+      is a dictionary whose keys are colors and whose values are the color classes
+      ( ideal to be plotted )
+
+    - ``log`` ( integer ) --
+      As edge-coloring is a `NP`-complete problem, its solving may take some time
+      depending on the graph. Use ``log`` to define the level of verbosity you want
+      from the linear program solver.
+
+      By default ``log=0``, meaning that there will be no message printed by the solver.
+
+    OUTPUT :
+
+    In the following, `\Delta` is equal to the maximum degree in the graph
+    
+    - If ``vizing=True`` and ``value_only=False``:
+              Returns a partition of the edge set into Delta+1 matchings
+
+    - If ``vizing=False`` and ``value_only=True``:
+              Returns the chromatic index
+
+    - If ``vizing=False`` and ``value_only=False``:
+              Returns a partition of the edge set into the minimum number of matchings
+              
+    - If ``vizing=True`` is set and ``value_only=True``:
+              Should return something, but mainly you are just trying to compute the maximum
+              degree of the graph, and this is not the easiest way ;-)
+               By Vizing's theorem, a graph has a chromatic index equal to `\Delta`
+              or to `\Delta+1`
+
+    EXAMPLE::
+    
+       sage: from sage.graphs.graph_coloring import edge_coloring
+       sage: g=graphs.PetersenGraph()
+       sage: edge_coloring(g, value_only=True) # optional - requires GLPK or CBC
+       4
+
+    Completes graphs are colored using the linear-time Round-robin coloring ::
+
+       sage: from sage.graphs.graph_coloring import edge_coloring
+       sage: len(edge_coloring(graphs.CompleteGraph(20)))
+       19
+       
+    """
+    from sage.numerical.mip import MixedIntegerLinearProgram
+    from sage.plot.colors import rainbow
+    g=self
+
+
+    if g.is_clique():
+        if value_only:
+            return g.order() if g.order() % 2 ==0 else g.order()+1
+        vertices=g.vertices()
+        r = round_robin(g.order())
+        classes=[[] for v in g]
+        if g.order() % 2 == 0 and vizing == False:
+            classes.pop()
+
+        for (u,v,c) in r.edge_iterator():
+            classes[c].append((vertices[u], vertices[v]))
+        
+        if hex_colors:
+            from sage.plot.colors import rainbow
+            return zip(rainbow(len(classes)),classes)
+        else:
+            return classes              
+        
+
+    p=MixedIntegerLinearProgram(maximization=True)
+    color=p.new_variable(dim=2)
+    obj={}
+    k=max(g.degree())
+
+    # reorders the edge if necessary...
+    R = lambda x : x if (x[0]<=x[1]) else (x[1],x[0],x[2])
+
+    # Vizing's coloring uses Delta+1 colors
+    if vizing:
+        value_only=False
+        k=k+1
+
+    #  A vertex can not have two incident edges with
+    # the same color
+    [p.add_constraint(sum([color[R(e)][i] for e in g.edges_incident(v)]),max=1) for v in g.vertex_iterator() for i in range(k)]
+
+    # An edge must have a color
+    [p.add_constraint(sum([color[R(e)][i] for i in range(k)]),max=1,min=1) for e in g.edge_iterator()]
+
+    # Anything is good as an objective value as long as it is satisfiable
+    e=g.edge_iterator().next()
+    p.set_objective(color[R(e)][0])
+
+    p.set_binary(color)
+    try: 
+        if value_only==True:
+            p.solve(objective_only=True,log=log)
+        else:
+            chi=p.solve(log=log)
+    except:
+        if value_only:
+            return k+1
+        else:
+            # if the coloring with Delta colors fails, tries Delta+1
+            return edge_coloring(g,vizing=True,hex_colors=hex_colors,log=log)
+    if value_only:
+        return k
+
+    # Builds the color classes
+    color=p.get_values(color)
+    classes=[[] for i in range(k)]
+    [classes[i].append(e) for e in g.edge_iterator() for i in range(k) if color[R(e)][i]==1]
+    # if needed, builds a dictionary from the color classes adding colors
+    if hex_colors:
+        return dict(zip(rainbow(len(classes)),classes))
+    else:
+        return classes
+
+def round_robin(n):
+    r"""
+    Computes a Round-robin coloring of the complete graph on `n` vertices.
+
+    A Round-robin coloring of the complete graph `G` on 
+    `2n` vertices (`V=[0,\dots,2n-1]`) is a proper coloring of its edges 
+    such that the edges with color `i` are all the `(i+j,i-j)`, plus the
+    edge `(2n-1,i)`.
+
+    If `n` is odd, one obtain a Round-robin coloring of the complete graph
+    through the Round-robin coloring of the graph with `n+1` vertices, to
+    which one is removed.
+
+    INPUT:
+
+    - ``n`` -- the number of vertices in the complete graph.
+
+    OUTPUT:
+
+    - A CompleteGraph with labelled edges, such that the label of each
+      edge is its color.
+
+    EXAMPLES::
+
+        sage: from sage.graphs.graph_coloring import round_robin
+        sage: round_robin(3).edges()
+        [(0, 1, 2), (0, 2, 1), (1, 2, 0)]
+
+    ::
+
+        sage: round_robin(4).edges()
+        [(0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 2, 0), (1, 3, 1), (2, 3, 2)]
+
+
+    For higher orders, the coloring is still proper and uses the expected
+    number of colors.
+
+    ::
+
+        sage: g = round_robin(9)
+        sage: sum([Set([e[2] for e in g.edges_incident(v)]).cardinality() for v in g]) == 2*g.size()
+        True
+        sage: Set([e[2] for e in g.edge_iterator()]).cardinality()
+        9
+
+    ::
+
+        sage: g = round_robin(10)
+        sage: sum([Set([e[2] for e in g.edges_incident(v)]).cardinality() for v in g]) == 2*g.size()
+        True
+        sage: Set([e[2] for e in g.edge_iterator()]).cardinality()
+        9        
+
+
+    """
+
+    if not (n>1):
+        raise ValueError, "There must be at least two vertices in the graph."
+
+    mod = lambda x,y : x - y*(x//y)
+
+    if n % 2 == 0:
+        g=GraphGenerators().CompleteGraph(n)
+        for i in range(n-1):
+            g.set_edge_label(n-1,i,i)
+            for j in range(1,(n-1)//2+1):
+                g.set_edge_label(mod(i-j,n-1),mod(i+j,n-1),i)
+
+        return g
+            
+    else:
+        g=round_robin(n+1)
+        g.delete_vertex(n)
+        return g
+
+
 class Test:
     """
     This class performs randomized testing for all_graph_colorings.