Ticket #6764: ISR.patch

sage/graphs/graph.py

@@ -10585 +10585 @@
         else:
             raise ValueError("The 'algorithm' keyword must be set to either 'DLX' or 'MILP'.")
     
+    def ISR(self,family):
+        r"""
+        Returns an independent set of representatives.
+
+        Given a graph `G` and and a family `F=\{F_i:i\in [1,...,k]\}` of subsets 
+        of ``g.vertices()``, an ISR ( Independent Set of Reprersentatives ) is an
+        assignation of a vertex `v_i\in F_i` to each set `F_i` such that 
+        `v_i != v_j` if `i<j` ( they are represdentatives ) and the set
+        `\cup_{i}v_i` is an independent set in `G`.
+        
+        It generalizes, for example, graph coloring and graph list coloring.
+        
+        ( See [AhaBerZiv07]_ for more informations )
+
+        INPUT :
+
+              * ``family`` : A list of lists defining the family `F`
+                ( actually, a Family of subsets of ``G.vertices()`` )
+
+        OUTPUT :
+        
+               A list whose `i^{\mbox{th}}` element is the representativeof the `i^{\mbox{th}}`
+               element of the ``family`` list. If there is no ISR, ``None`` is returned
+
+        EXAMPLE ::
+        
+           sage: g=graphs.CompleteBipartiteGraph(3,3)
+           sage: g.delete_edge(1,4)
+           sage: g.ISR([[0,1,2],[3,4,5]])
+           [1, 4]
+           
+
+        REFERENCE:
+
+        .. [AhaBerZiv07] R. Aharoni and E. Berger and R. Ziv
+          Independent systems of representatives in weighted graphs
+          Combinatorica vol 27, num 3, p253--267
+          2007
+
+        """
+
+        from sage.numerical.mip import MIP
+        p=MIP()
+        
+        # Boolean variable indicating whether the vertex
+        # is the representative of some set
+        vertex_taken=p.newvar()
+
+        # Boolean variable in two dimension whose first
+        # element is a vertex and whose second element
+        # is one of the sets given as arguments.
+        # When true, indicated that the vertex is the representent
+        # of the corresponding set
+
+        classss=p.newvar(dim=2)
+
+        # Associates to the vertices the classsses 
+        # to which they belong
+        
+        lists={}
+        for v in self.vertices():
+            lists[v]=[]
+
+        for i in range(len(family)):
+            for v in family[i]:
+                assert v in self, "All the vertices must belong to the graph !"
+            
+            [lists[v].append(i) for v in family[i]]
+            
+            # a classss has exactly one representant
+            p.addconstraint(sum([classss[v][i] for v in family[i]]),max=1,min=1)
+
+        # A vertex represents at most one classss (vertex_taken is binary), and
+        # vertex_taken[v]==1 if v is the representative of some classss
+
+        [p.addconstraint(sum([classss[v][i] for i in lists[v]])-vertex_taken[v],max=0) for v in self.vertices()]
+
+        # Two adjacent vertices can not both be representants of a set
+
+        for (u,v) in self.edges(labels=None):
+            p.addconstraint(vertex_taken[u]+vertex_taken[v],max=1)
+
+        p.setobj(sum([vertex_taken[v] for v in self.vertices()]))
+
+        p.setbinary(vertex_taken)
+        p.setbinary(classss)
+
+        try:
+            p.solve()
+        except:
+            return None
+
+        classss=p.get_values(classss)
+        
+        repr=[]
+        for i in range(len(family)):
+            for v in family[i]:
+                if classss[v][i]==1:
+                    repr.append(v)
+                    break
+
+        return repr
+
     ### Centrality
 
     def centrality_betweenness(self, normalized=True):