Vertex cover

docs/src/algorithms.md

@@ -61,6 +61,14 @@ min_cost_assignment
 GraphsOptim.min_cost_assignment!
 ```
 
+## Minimum Vertex Cover
+
+```@docs
+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$
+
 ## Graph matching
 
 !!! danger "Work in progress"

src/GraphsOptim.jl

@@ -23,13 +23,15 @@ using OptimalTransport: sinkhorn
 export min_cost_flow
 export min_cost_assignment
 export FAQ, GOAT, graph_matching
+export min_vertex_cover
 export fractional_chromatic_number, fractional_clique_number
 export shortest_path
 
 include("utils.jl")
 include("flow.jl")
 include("assignment.jl")
 include("graph_matching.jl")
+include("vertex_cover.jl")
 include("fractional_coloring.jl")
 include("shortest_path.jl")
 

src/vertex_cover.jl

@@ -0,0 +1,68 @@
+"""
+    vertex_cover!(
+        model, g;
+        var_name
+    )
+
+Modify a JuMP model by adding the variable, constraints and objective necessary to compute a minimum vertex cove of an undirected graph.
+
+The vertex cover indicator variable will be named `var_name`
+"""
+function min_vertex_cover!(model::Model, g::AbstractGraph; var_name)
+    if is_directed(g)
+        throw(ArgumentError("The graph must not be directed"))
+    end
+
+    ver = collect(vertices(g))
+    edge_tuples = [(src(ed), dst(ed)) for ed in edges(g)]
+
+    f = @variable(model, [ver]; integer=true, base_name=String(var_name))
+    model[Symbol(var_name)] = f
+
+    for v in ver
+        @constraint(model, f[v] >= 0)
+        @constraint(model, f[v] <= 1)
+    end
+
+    for (u, v) in edge_tuples
+        @constraint(model, f[u] + f[v] >= 1)
+    end
+
+    obj = objective_function(model)
+    for v in ver
+        add_to_expression!(obj, f[v])
+    end
+    @objective(model, Min, obj)
+
+    return model
+end
+
+"""
+    vertex_cover(
+        g, optimizer
+    )
+
+Compute a minimum vertex cover of an undirected graph.
+
+# Arguments
+
+- `g::Graphs.AbstractGraph`: an undirected graph `G = (V, E)`
+
+# Keyword arguments
+
+- `optimizer`: JuMP-compatible solver (default is `HiGHS.Optimizer`)
+"""
+function min_vertex_cover(g::AbstractGraph; optimizer=HiGHS.Optimizer)
+    model = Model(optimizer)
+    set_silent(model)
+
+    min_vertex_cover!(model, g; var_name=:cover)
+
+    optimize!(model)
+    @assert termination_status(model) == OPTIMAL
+
+    cover_values = Vector(value.(model[:cover]))
+    cover_vertices = findall(==(1), cover_values)
+
+    return cover_vertices
+end

test/runtests.jl

@@ -40,6 +40,10 @@ using Test
         include("graph_matching.jl")
     end
 
+    @testset verbose = true "Vertex cover" begin
+        include("vertex_cover.jl")
+    end
+
     @testset verbose = true "Fractional coloring" begin
         include("fractional_coloring.jl")
     end

test/vertex_cover.jl

@@ -0,0 +1,18 @@
+using Graphs: SimpleGraph
+using GraphsOptim
+using Test
+
+adj_matrix = [
+    0 1 1 0 0 0
+    1 0 1 1 1 1
+    1 1 0 0 0 0
+    0 1 0 0 0 0
+    0 1 0 0 0 0
+    0 1 0 0 0 0
+]
+
+expected_ans_options = Set([Set([1, 2]), Set([2, 3])])
+
+graph = SimpleGraph(adj_matrix)
+
+@test Set(min_vertex_cover(graph)) in expected_ans_options