Ticket #6679: coloring-symbolic.patch

sage/graphs/graph.py

@@ -9841 +9841 @@
             else:
                 return C.values()
 
+
+    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`` : 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: g=graphs.PetersenGraph()
+           sage: g.vertex_coloring(value_only=True)
+           3
+           
+        """
+        from sage.numerical.mip import MIP
+        from sage.plot.colors import rainbow
+        g=self
+        if k==None:
+            # no need to start a linear program if the graph is an independent set or bipartite
+            if g.size()==0:
+                return ([g.vertices] if value_only==False else g.order())
+            if g.is_bipartite():
+                if value_only==True:
+                    return 2
+                tmp=g.bipartite_sets()
+                return [tmp[0],tmp[1]]
+            # no need to try any k smaller than the maximum clique in the graph
+            k=g.clique_number()
+    
+            while True:
+                # tries to color the graph, increasing k each time it fails.
+                tmp=g.vertex_coloring(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
+                if 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 g.subgraph(component).vertex_coloring(k=k,value_only=value_only,hex_colors=hex_colors,log=log)==False:
+                            return False
+                    return True
+                if hex_colors==True:
+                    colorings=[]
+                    for component in g.connected_components():
+                        tmp=g.subgraph(component).vertex_coloring(k=k,value_only=value_only,hex_colors=True,log=log)
+                        if tmp==False:
+                            return False
+                        colorings.append(tmp)
+                    value=dict([(color,[]) for color in rainbow(k)])
+                    for color in rainbow(k):
+                        for component in colorings:
+                            value[color].extend(component[color])
+                    return value
+                else:
+                    colorings=[]
+                    for component in g.connected_components():
+                        tmp=g.subgraph(component).vertex_coloring(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])
+                    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 g.subgraph(list(vertices)).vertex_coloring(k=k,value_only=value_only,hex_colors=hex_colors,log=log)
+                if hex_colors==True:
+                    value=g.subgraph(list(vertices)).vertex_coloring(k=k,value_only=value_only,hex_colors=hex_colors,log=log)
+                    if value==False:
+                        return False
+                    while len(deg)>0:
+                        for (color,classe) in value.items():
+                            if len(list(set(classe) & set(g.neighbors(deg[-1]))))==0:
+                                value[color].append(deg[-1])
+                                deg.pop(-1)
+                                break
+                    return value
+                else:
+                    value=g.subgraph(list(vertices)).vertex_coloring(k=k,value_only=value_only,hex_colors=hex_colors,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
+                    return value
+    
+                
+                
+                
+            p=MIP(sense=1)
+            color=p.newvar(dim=2)
+
+            # a vertex has exactly only one color
+            [p.addconstraint(sum([color[v][i] for i in range(k)]),min=1,max=1) for v in g.vertices()]
+    
+            # Adjacent vertices have different colors
+            [p.addconstraint(color[u][i]+color[v][i],max=1) for (u,v) in g.edges(labels=None) for i in range(k)]
+
+            # Anything is good as an objective value as long as it is satisfiable
+            p.setobj(color[g.vertices()[0]][0])
+
+            p.setbinary(color)
+
+            try:
+                if value_only==True:
+                    p.solve(objective_only=True,log=log)
+                    return True
+                else:
+                    chi=p.solve(log=log)
+            except:
+                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`` : 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`` ( an 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`` :
+                           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: g=graphs.PetersenGraph()
+           sage: g.edge_coloring(value_only=True)
+           4
+           
+        """
+        from sage.numerical.mip import MIP
+        from sage.plot.colors import rainbow
+        g=self
+    
+        p=MIP(sense=1)
+        color=p.newvar(dim=3)
+        obj={}
+        k=max(g.degree())
+        # 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.addconstraint(sum([color[min(u,v)][max(u,v)][i] for u in g.neighbors(v)]),max=1) for v in g.vertices() for i in range(k)]
+
+        # An edge must have a color
+        [p.addconstraint(sum([color[min(u,v)][max(u,v)][i] for i in range(k)]),max=1,min=1) for (u,v) in g.edges(labels=None)]
+
+        # Anything is good as an objective value as long as it is satisfiable
+        (u,v)=g.edges(labels=None)[0]
+        p.setobj(color[min(u,v)][max(u,v)][0])
+        p.setbinary(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 g.edge_coloring(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((u,v)) for (u,v) in g.edges(labels=None) for i in range(k) if color[min(u,v)][max(u,v)][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
+    
     ### Centrality
     
     def centrality_betweenness(self, normalized=True):