independent set

Author: matbesancon

docs/src/algorithms.md

@@ -70,6 +70,15 @@ GraphsOptim.min_vertex_cover!
 
 Finds a subset $S \subset V$ of vertices of an undirected graph $G = (V,E)$ such that $\forall (u,v) \in E: u \in S \lor v \in S$
 
+## Maximum Weight Independent Set
+
+```@docs
+maximum_weight_independent_set
+GraphsOptim.maximum_weight_independent_set!
+```
+
+Finds a subset $S \subset V$ of vertices of maximal weight of an undirected graph $G = (V,E)$ such that $\forall (u,v) \in E: u \notin S \lor v \notin S$.
+
 ## Graph matching
 
 !!! danger "Work in progress"

src/GraphsOptim.jl

@@ -34,5 +34,6 @@ include("graph_matching.jl")
 include("min_vertex_cover.jl")
 include("fractional_coloring.jl")
 include("shortest_path.jl")
+include("independent_set.jl")
 
 end

src/independent_set.jl

@@ -0,0 +1,47 @@
+
+"""
+    maximum_independent_set!(model, g; var_name)
+
+Computes in-place in the JuMP model a maximum-weighted independent set of `g`.
+An optional `vertex_weights` vector can be passed to the graph, defaulting to uniform weights (computing a maximum size independent set).
+"""
+function maximum_weight_independent_set!(
+    model::Model, g::AbstractGraph; binary::Bool=true, var_name, vertex_weights=ones(nv(g))
+)
+    if is_directed(g)
+        throw(ArgumentError("The graph must not be directed"))
+    end
+    g_vertices = collect(vertices(g))
+    f = @variable(model, [g_vertices]; binary=binary, base_name=String(var_name))
+    model[Symbol(var_name)] = f
+    @constraint(
+        model,
+        covering_constraint[i=1:nv(g), j=1:nv(g); i ≠ j && has_edge(g, i, j)],
+        f[i] + f[j] <= 1,
+    )
+    @objective(model, Max, dot(f, vertex_weights))
+    return model
+end
+
+"""
+    maximum_weight_independent_set(g; optimizer, binary, vertex_weights)
+
+Computes a maximum-weighted independent set or stable set of `g`.
+"""
+function maximum_weight_independent_set(
+    g::AbstractGraph;
+    binary::Bool=true,
+    vertex_weights=ones(nv(g)),
+    optimizer=HiGHS.Optimizer,
+)
+    model = Model(optimizer)
+    set_silent(model)
+    maximum_weight_independent_set!(
+        model, g; binary=binary, vertex_weights=vertex_weights, var_name=:stable
+    )
+    optimize!(model)
+    @assert termination_status(model) == OPTIMAL
+    stable_variables = Vector(model[:stable])
+    stable_vertices = findall(v -> value(v) > 0.5, stable_variables)
+    return stable_vertices
+end

test/independent_set.jl

@@ -0,0 +1,22 @@
+using GraphsOptim
+using Graphs
+using Test
+
+g = Graphs.random_regular_graph(10, 5)
+
+for _ in 1:10
+    vertex_weights = rand(nv(g))
+    stable = GraphsOptim.maximum_weight_independent_set(g; vertex_weights=vertex_weights)
+    if length(stable) > 1
+        for idx in 1:(length(stable) - 1)
+            @test !Graphs.has_edge(g, stable[idx], stable[idx + 1])
+        end
+    end
+end
+
+g2 = complete_graph(3)
+add_vertex!(g2)
+add_edge!(g2, 3, 4)
+stable = GraphsOptim.maximum_weight_independent_set(g2)
+@test length(stable) == 2
+@test 4 in stable

test/runtests.jl

@@ -44,6 +44,10 @@ using Test
         include("min_vertex_cover.jl")
     end
 
+    @testset verbose = true "Independent set" begin
+        include("independent_set.jl")
+    end
+
     @testset verbose = true "Fractional coloring" begin
         include("fractional_coloring.jl")
     end