add weights for Sat, Matching and Coloring (#29)

Author: GiggleLiu

docs/src/ref.md

@@ -47,6 +47,8 @@ paint_shop_coloring_from_config
 
 is_good_vertex_coloring
 
+is_matching
+
 CNF
 CNFClause
 BoolVar

src/GraphTensorNetworks.jl

@@ -42,6 +42,7 @@ export mis_compactify!, cut_size, num_paint_shop_color_switch, paint_shop_colori
 export is_good_vertex_coloring
 export CNF, CNFClause, BoolVar, satisfiable, @bools, ∨, ¬, ∧
 export is_dominating_set
+export is_matching
 
 # Interfaces
 export solve, SizeMax, SizeMin, CountingAll, CountingMax, CountingMin, GraphPolynomial, SingleConfigMax, SingleConfigMin, ConfigsAll, ConfigsMax, ConfigsMin

src/networks/Coloring.jl

@@ -1,33 +1,34 @@
 """
-    Coloring{K,CT<:AbstractEinsum} <: GraphProblem
-    Coloring{K}(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+    Coloring{K,CT<:AbstractEinsum, WT<:Union{NoWeight, Vector}} <: GraphProblem
+    Coloring{K}(graph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
 The [Vertex Coloring](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/Coloring.html) problem.
+`weights` has one to one correspondence with `edges(graph)`.
 `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
 """
-struct Coloring{K,CT<:AbstractEinsum} <: GraphProblem
+struct Coloring{K,CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT
     graph::SimpleGraph{Int}
+    weights::WT
 end
-Coloring{K}(code::ET, graph::SimpleGraph) where {K,ET<:AbstractEinsum} = Coloring{K,ET}(code, graph)
+Coloring{K}(code::ET, graph::SimpleGraph, weights::Union{NoWeight, Vector}) where {K,ET<:AbstractEinsum} = Coloring{K,ET,typeof(weights)}(code, graph, weights)
 # same network layout as independent set.
-function Coloring{K}(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing) where K
+function Coloring{K}(g::SimpleGraph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing) where K
+    @assert weights isa NoWeight || length(weights) == ne(g)
     rawcode = EinCode(([[i] for i in Graphs.vertices(g)]..., # labels for vertex tensors
                        [[minmax(e.src,e.dst)...] for e in Graphs.edges(g)]...), collect(Int, openvertices))  # labels for edge tensors
     code = _optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier)
-    Coloring{K}(code, g)
+    Coloring{K}(code, g, weights)
 end
 
 flavors(::Type{<:Coloring{K}}) where K = collect(0:K-1)
-get_weights(::Coloring{K}, i::Int) where K = ones(Int, K)
+get_weights(c::Coloring{K}, i::Int) where K = fill(c.weights[i], K)
 terms(gp::Coloring) = getixsv(gp.code)[1:nv(gp.graph)]
 labels(gp::Coloring) = [1:nv(gp.graph)...]
 
 function generate_tensors(x::T, c::Coloring{K}) where {K,T}
     ixs = getixsv(c.code)
-    return add_labels!(map(1:length(ixs)) do i
-        i <= nv(c.graph) ? coloringv(T, K) .^ get_weights(c, i) : coloringb(x, K)
-    end, ixs, labels(c))
+    return vcat(add_labels!([coloringv(T, K) for i=1:nv(c.graph)], ixs[1:nv(c.graph)], labels(c)), [coloringb(x, K) .^ get_weights(c, i) for i=1:ne(c.graph)])
 end
 
 # coloring bond tensor

src/networks/DominatingSet.jl

@@ -4,7 +4,7 @@
                  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.
+In the constructor, `weights` are associated with vertices.
 `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
 """
 struct DominatingSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem

src/networks/Matching.jl

@@ -1,25 +1,28 @@
 """
-    Matching{CT<:AbstractEinsum} <: GraphProblem
-    Matching(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+    Matching{CT<:AbstractEinsum, WT<:Union{NoWeight,Vector}} <: GraphProblem
+    Matching(graph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
 The [Vertex matching](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/Matching.html) problem.
+`weights` has one to one correspondence with `edges(graph)`.
 `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
 """
-struct Matching{CT<:AbstractEinsum} <: GraphProblem
+struct Matching{CT<:AbstractEinsum, WT<:Union{NoWeight,Vector}} <: GraphProblem
     code::CT
     graph::SimpleGraph{Int}
+    weights::WT
 end
 
-function Matching(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+function Matching(g::SimpleGraph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
+    @assert weights isa NoWeight || length(weights) == ne(g)
     edges = [minmax(e.src,e.dst) for e in Graphs.edges(g)]
     rawcode = EinCode(vcat([[s] for s in edges], # labels for edge tensors
                 [[minmax(i,j) for j in neighbors(g, i)] for i in Graphs.vertices(g)]),
                 collect(Tuple{Int,Int}, openvertices))
-    Matching(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), g)
+    Matching(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), g, weights)
 end
 
 flavors(::Type{<:Matching}) = [0, 1]
-get_weights(::Matching, i::Int) = [0, 1]
+get_weights(m::Matching, i::Int) = [0, m.weights[i]]
 terms(gp::Matching) = getixsv(gp.code)[1:ne(gp.graph)]
 labels(gp::Matching) = getindex.(terms(gp))
 
@@ -50,3 +53,28 @@ function match_tensor(::Type{T}, n::Int) where T
     return t
 end
 
+"""
+    is_matching(graph::SimpleGraph, config)
+
+Returns true if `config` is a valid matching on `graph`, and `false` if a vertex is double matched.
+`config` is a vector of boolean variables, which has one to one correspondence with `edges(graph)`.
+"""
+function is_matching(g::SimpleGraph, config)
+    @assert ne(g) == length(config)
+    edges_mask = zeros(Bool, nv(g))
+    for (e, c) in zip(edges(g), config)
+        if !iszero(c)
+            if edges_mask[e.src]
+                @debug "Vertex $(e.src) is double matched!"
+                return false
+            end
+            if edges_mask[e.dst]
+                @debug "Vertex $(e.dst) is double matched!"
+                return false
+            end
+            edges_mask[e.src] = true
+            edges_mask[e.dst] = true
+        end
+    end
+    return true
+end

src/networks/Satisfiability.jl

@@ -57,6 +57,7 @@ function Base.show(io::IO, c::CNF)
     print(io, join(["($k)" for k in c.clauses], " ∧ "))
 end
 Base.:(==)(x::CNF, y::CNF) = x.clauses == y.clauses
+Base.length(x::CNF) = length(x.clauses)
 
 """
     ¬(var::BoolVar)
@@ -106,26 +107,28 @@ macro bools(syms::Symbol...)
 end
 
 """
-    Satisfiability{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
-    Satisfiability(cnf::CNF; openvertices=(),
+    Satisfiability{CT<:AbstractEinsum,T,WT<:Union{NoWeight, Vector}} <: GraphProblem
+    Satisfiability(cnf::CNF; weights=NoWeight(), openvertices=(),
                  optimizer=GreedyMethod(), simplifier=nothing)
 
 The [satisfiability](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorials/Satisfiability.html) problem.
 In the constructor, `cnf` is a logical expresion in conjunctive normal form ([`CNF`](@ref)) for the satisfiability problems.
+`weights` are associated with clauses.
 `optimizer` and `simplifier` are for tensor network optimization, check [`optimize_code`](@ref) for details.
 """
-struct Satisfiability{CT<:AbstractEinsum,T} <: GraphProblem
+struct Satisfiability{CT<:AbstractEinsum,T,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT
     cnf::CNF{T}
+    weights::WT
 end
 
-function Satisfiability(cnf::CNF{T}; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing) where T
+function Satisfiability(cnf::CNF{T}; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing) where T
     rawcode = EinCode([[getfield.(c.vars, :name)...] for c in cnf.clauses], collect(T, openvertices))
-    Satisfiability(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), cnf)
+    Satisfiability(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), cnf, weights)
 end
 
 flavors(::Type{<:Satisfiability}) = [0, 1]  # false, true
-get_weights(::Satisfiability, sym) = [0, 1]
+get_weights(s::Satisfiability, i::Int) = [0, s.weights[i]]
 terms(gp::Satisfiability) = getixsv(gp.code)
 labels(gp::Satisfiability) = unique!(vcat(getixsv(gp.code)...))
 

test/networks/Coloring.jl

@@ -18,3 +18,11 @@ using Test, GraphTensorNetworks, Graphs
     @test is_good_vertex_coloring(g, c.c.data)
 end
 
+
+@testset "weighted coloring" begin
+    g = smallgraph(:petersen)
+    problem = Coloring{3}(g; weights=fill(2, 15))
+    @test solve(problem, SizeMax())[].n == 30
+    res = solve(problem, SingleConfigMax())[].c.data
+    @test is_good_vertex_coloring(g, res)
+end

test/networks/Matching.jl

@@ -16,4 +16,13 @@ end
     @test graph_polynomial(Matching(g), Val(:polynomial))[] == Polynomial([1,7,13,5])
     g = smallgraph(:petersen)
     @test graph_polynomial(Matching(g), Val(:polynomial))[].coeffs == [6, 90, 145, 75, 15, 1][end:-1:1]
+end
+
+@testset "weighted matching" begin
+    g = smallgraph(:petersen)
+    problem = Matching(g; weights=fill(2, 15))
+    @test solve(problem, SizeMax())[].n == 10
+    res = solve(problem, SingleConfigMax())[].c.data
+    @test is_matching(g, res)
+    @test count_ones(res) * 2 == 10
 end

test/networks/Satisfiability.jl

@@ -23,7 +23,7 @@ using GraphTensorNetworks
     @test !satisfiable(cnf, Dict(:x=>false, :y=>true, :z=>true, :a=>false, :b=>false, :c=>true))
 end
 
-@testset "enumerating - max cut" begin
+@testset "enumeration - sat" begin
     @bools x y z a b c
     c1 = x ∨ ¬y
     c2 = c ∨ (¬a ∨ b)
@@ -44,3 +44,24 @@ end
     end
 end
 
+@testset "weighted cnf" begin
+    @bools x y z a b c
+    c1 = x ∨ ¬y
+    c2 = c ∨ (¬a ∨ b)
+    c3 = (z ∨ ¬a) ∨ y
+    c4 = (c ∨ z) ∨ ¬b
+    cnf = (c1 ∧ c4) ∧ (c2 ∧ c3)
+    gp = Satisfiability(cnf; weights=fill(2, length(cnf)))
+
+    @test solve(gp, SizeMax())[].n == 8.0
+    res = best_solutions(gp; all=true)[].c.data
+    for i=0:1<<6-1
+        v = StaticBitVector(Bool[i>>(k-1) & 1 for k=1:6])
+        if v ∈ res
+            @test satisfiable(gp.cnf, Dict(zip(labels(gp), v)))
+        else
+            @test !satisfiable(gp.cnf, Dict(zip(labels(gp), v)))
+        end
+    end
+end
+