Dominating sets (#21)

* new dominating sets

* update

Author: GiggleLiu

docs/make.jl

@@ -36,6 +36,7 @@ makedocs(;
             "Matching problem" => "tutorials/Matching.md",
             "Binary paint shop problem" => "tutorials/PaintShop.md",
             "Coloring problem" => "tutorials/Coloring.md",
+            "Dominating set problem" => "tutorials/DominatingSet.md",
             "Satisfiability problem" => "tutorials/Satisfiability.md",
             "Other problems" => "tutorials/Others.md",
         ],

docs/src/ref.md

@@ -7,6 +7,7 @@ IndependentSet
 MaximalIS
 Matching
 Coloring
+DominatingSet
 MaxCut
 PaintShop
 Satisfiability
@@ -37,6 +38,8 @@ mis_compactify!
 
 is_maximal_independent_set
 
+is_dominating_set
+
 cut_size
 
 num_paint_shop_color_switch

examples/DominatingSet.jl

@@ -0,0 +1,90 @@
+# # Dominating set problem
+
+# !!! note
+#     It is recommended to read the [Independent set problem](@ref) tutorial first to know more about
+#     * how to optimize the tensor network contraction order,
+#     * what graph properties are available and how to select correct method to compute graph properties,
+#     * how to compute weighted graphs and handle open vertices.
+
+# ## Problem definition
+
+# In graph theory, a [dominating set](https://en.wikipedia.org/wiki/Dominating_set) for a graph ``G = (V, E)`` is a subset ``D`` of ``V`` such that every vertex not in ``D`` is adjacent to at least one member of ``D``.
+# The domination number ``\gamma(G)`` is the number of vertices in a smallest dominating set for ``G``.
+# The decision version of finding the minimum dominating set is an NP-complete.
+# In the following, we are going to solve the dominating set problem on the Petersen graph.
+
+using GraphTensorNetworks, Graphs, Compose
+
+graph = Graphs.smallgraph(:petersen)
+
+# We can visualize this graph using the following function
+rot15(a, b, i::Int) = cos(2i*π/5)*a + sin(2i*π/5)*b, cos(2i*π/5)*b - sin(2i*π/5)*a
+
+locations = [[rot15(0.0, 1.0, i) for i=0:4]..., [rot15(0.0, 0.6, i) for i=0:4]...]
+
+show_graph(graph; locs=locations)
+
+# ## Tensor network representation
+# Let ``G=(V,E)`` be the target graph that we want to solve.
+# The tensor network representation map a vertex ``v\in V`` to a boolean degree of freedom ``s_v\in\{0, 1\}``.
+# We defined the restriction on a vertex and its neighbouring vertices ``N(v)``:
+# ```math
+# T(x_v)_{s_1,s_2,\ldots,s_{|N(v)|},s_v} = \begin{cases}
+#     0 & s_1=s_2=\ldots=s_{|N(v)|}=s_v=0,\\
+#     1 & s_v=0,\\
+#     x_v^{w_v} & \text{otherwise},
+# \end{cases}
+# ```
+# where ``w_v`` is the weight of vertex ``v``.
+# This tensor means if both ``v`` and its neighbouring vertices are not in ``D``, i.e., ``s_1=s_2=\ldots=s_{|N(v)|}=s_v=0``,
+# this configuration is forbidden because ``v`` is not adjacent to any member in the set.
+# otherwise, if ``v`` is in ``D``, it has a contribution ``x_v^{w_v}`` to the final result.
+# We can use [`DominatingSet`](@ref) to construct the tensor network for solving the dominating set problem as
+problem = DominatingSet(graph; optimizer=TreeSA());
+
+# One can check the contraction time space complexity of a [`DominatingSet`](@ref) instance by typing:
+
+timespacereadwrite_complexity(problem)
+
+# Results are `log2` values of time (number of iterations),
+# space (number of items in the largest tensor)
+# and read-write (number of read-write of operations to elements).
+
+# ## Solving properties
+
+# ### Counting properties
+# ##### Domination polynomial
+# The graph polynomial for the dominating set problem is known as the domination polynomial (see [arXiv:0905.2251](https://arxiv.org/abs/0905.2251)).
+# It is defined as
+# ```math
+# D(G, x) = \sum_{k=0}^{\gamma(G)} d_k x^k,
+# ```
+# where ``d_k`` is the number of dominating sets of size ``k`` in graph ``G=(V, E)``.
+
+domination_polynomial = solve(problem, GraphPolynomial())[]
+
+# The domination number ``\gamma(G)`` can be computed with the [`SizeMin`](@ref) property:
+domination_number = solve(problem, SizeMin())[]
+
+# Similarly, we have its counting [`CountingMin`](@ref):
+counting_min_dominating_set = solve(problem, CountingMin())[]
+
+# ### Configuration properties
+# ##### finding all dominating set
+# One can enumerate all minimum dominating sets with the [`ConfigsMin`](@ref) property in the program.
+min_configs = solve(problem, ConfigsMin())[].c
+
+all(c->is_dominating_set(graph, c), min_configs)
+
+# ##### finding minimum dominating set
+
+imgs = ntuple(k->show_graph(graph;
+                locs=locations, scale=0.25,
+                vertex_colors=[iszero(min_configs[k][i]) ? "white" : "red"
+                for i=1:nv(graph)]), length(min_configs));
+
+Compose.set_default_graphic_size(18cm, 8cm); Compose.compose(context(),
+     ntuple(k->(context((mod1(k,5)-1)/5, ((k-1)÷5)/2, 1.2/5, 1.0/2), imgs[k]), 10)...)
+
+# Similarly, if one is only interested in computing one of the minimum dominating sets,
+# one can use the graph property [`SingleConfigMin`](@ref).

examples/MaximalIS.jl

@@ -26,7 +26,7 @@ show_graph(graph; locs=locations)
 # ## Tensor network representation
 # Let ``G=(V,E)`` be the target graph that we want to solve.
 # The tensor network representation map a vertex ``v\in V`` to a boolean degree of freedom ``s_v\in\{0, 1\}``.
-# We defined the restriction on its neighbourhood ``N[v]``:
+# We defined the restriction on its neighbourhood ``N(v)``:
 # ```math
 # T(x_v)_{s_1,s_2,\ldots,s_{|N(v)|},s_v} = \begin{cases}
 #     s_vx_v & s_1=s_2=\ldots=s_{|N(v)|}=0,\\

examples/PaintShop.jl

@@ -79,9 +79,9 @@ max_config = solve(problem, GraphPolynomial())[]
 # ##### graph polynomial
 # The graph polynomial of the binary paint shop problem in our convension is defined as
 # ```math
-# D(G, x) = \sum_{k=0}^{\delta(G)} d_k x^k 
+# P(G, x) = \sum_{k=0}^{\delta(G)} p_k x^k 
 # ```
-# where ``d_k`` is the number of possible coloring with number of color changes ``2m-1-k``.
+# where ``p_k`` is the number of possible coloring with number of color changes ``2m-1-k``.
 paint_polynomial = solve(problem, GraphPolynomial())[]
 
 # ### Configuration properties

src/GraphTensorNetworks.jl

@@ -30,12 +30,13 @@ export line_graph
 
 # Tensor Networks (Graph problems)
 export GraphProblem, IndependentSet, MaximalIS, Matching, 
-    Coloring, optimize_code, set_packing, MaxCut, PaintShop,
+    Coloring, optimize_code, set_packing, MaxCut, PaintShop, DominatingSet,
     paintshop_from_pairs, NoWeight, Satisfiability
 export flavors, labels, terms, nflavor, get_weights
 export mis_compactify!, cut_size, num_paint_shop_color_switch, paint_shop_coloring_from_config
 export is_good_vertex_coloring
 export CNF, CNFClause, BoolVar, satisfiable, @bools, ∨, ¬, ∧
+export is_dominating_set
 
 # Interfaces
 export solve, SizeMax, SizeMin, CountingAll, CountingMax, CountingMin, GraphPolynomial, SingleConfigMax, SingleConfigMin, ConfigsAll, ConfigsMax, ConfigsMin

src/networks/DominatingSet.jl

@@ -0,0 +1,47 @@
+"""
+    DominatingSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
+    DominatingSet(graph; weights=NoWeight(), openvertices=(),
+                 optimizer=GreedyMethod(), simplifier=nothing)
+
+The [dominating set](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/DominatingSet.html) problem.
+In the constructor, `weights` are the weights of vertices.
+`optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
+"""
+struct DominatingSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
+    code::CT
+    weights::WT
+end
+
+function DominatingSet(g::SimpleGraph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+    @assert weights isa NoWeight || length(weights) == nv(g)
+    rawcode = EinCode(([[Graphs.neighbors(g, v)..., v] for v in Graphs.vertices(g)]...,), collect(Int, openvertices))
+    DominatingSet(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), weights)
+end
+
+flavors(::Type{<:DominatingSet}) = [0, 1]
+get_weights(gp::DominatingSet, i::Int) = [0, gp.weights[i]]
+terms(gp::DominatingSet) = getixsv(gp.code)
+labels(gp::DominatingSet) = [1:length(getixsv(gp.code))...]
+
+function generate_tensors(x::T, mi::DominatingSet) where T
+    ixs = getixsv(mi.code)
+    isempty(ixs) && return []
+	return add_labels!(map(enumerate(ixs)) do (i, ix)
+        dominating_set_tensor((Ref(x) .^ get_weights(mi, i))..., length(ix))
+    end, ixs, labels(mi))
+end
+function dominating_set_tensor(a::T, b::T, d::Int) where T
+    t = zeros(T, fill(2, d)...)
+    for i = 2:1<<(d-1)
+        t[i] = a
+    end
+    t[1<<(d-1)+1:end] .= Ref(b)
+    return t
+end
+
+"""
+    is_dominating_set(g::SimpleGraph, config)
+
+Return true if `config` (a vector of boolean numbers as the mask of vertices) is a dominating set of graph `g`.
+"""
+is_dominating_set(g::SimpleGraph, config) = all(w->config[w] == 1 || any(v->!iszero(config[v]), neighbors(g, w)), Graphs.vertices(g))

src/networks/MaximalIS.jl

@@ -26,15 +26,14 @@ function generate_tensors(x::T, mi::MaximalIS) where T
     ixs = getixsv(mi.code)
     isempty(ixs) && return []
 	return add_labels!(map(enumerate(ixs)) do (i, ix)
-        neighbortensor((Ref(x) .^ get_weights(mi, i))..., length(ix))
+        maximal_independent_set_tensor((Ref(x) .^ get_weights(mi, i))..., length(ix))
     end, ixs, labels(mi))
 end
-function neighbortensor(a::T, b::T, d::Int) where T
+function maximal_independent_set_tensor(a::T, b::T, d::Int) where T
     t = zeros(T, fill(2, d)...)
     for i = 2:1<<(d-1)
-        t[i] = one(T)
+        t[i] = a
     end
-    t[1<<(d-1)+1] = a
     t[1<<(d-1)+1] = b
     return t
 end

src/networks/networks.jl

@@ -106,6 +106,7 @@ include("Matching.jl")
 include("Coloring.jl")
 include("PaintShop.jl")
 include("Satisfiability.jl")
+include("DominatingSet.jl")
 
 # forward the time, space and readwrite complexity
 OMEinsum.timespacereadwrite_complexity(gp::GraphProblem) = timespacereadwrite_complexity(gp.code, uniformsize(gp.code, nflavor(gp)))

test/networks/DominatingSet.jl

@@ -0,0 +1,27 @@
+using GraphTensorNetworks, Test, Graphs
+
+@testset "dominating set basic" begin
+    g = smallgraph(:petersen)
+    mask = trues(10)
+    mask[neighbors(g, 1)] .= false
+    @test is_dominating_set(g, mask)
+    mask[1] = false
+    @test !is_dominating_set(g, mask)
+
+    @test GraphTensorNetworks.dominating_set_tensor(TropicalF64(0), TropicalF64(1), 3)[:,:,1] == TropicalF64[-Inf 0.0; 0 0]
+    @test GraphTensorNetworks.dominating_set_tensor(TropicalF64(0), TropicalF64(1), 3)[:,:,2] == TropicalF64[1.0 1.0; 1.0 1.0]
+end
+
+@testset "dominating set v.s. maximal IS" begin
+    g = smallgraph(:petersen)
+    gp1 = DominatingSet(g)
+    @test solve(gp1, SizeMax())[].n == 10
+    res1 = solve(gp1, ConfigsMin())[].c
+    gp2 = MaximalIS(g)
+    res2 = solve(gp2, ConfigsMin())[].c
+    @test res1 == res2
+    configs = solve(gp2, ConfigsAll())[]
+    for config in configs
+        @test is_dominating_set(g, config)
+    end
+end