add graph to problem as a field

Author: GiggleLiu

src/networks/Coloring.jl

@@ -7,26 +7,26 @@ The [Vertex Coloring](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorial
 """
 struct Coloring{K,CT<:AbstractEinsum} <: GraphProblem
     code::CT
-    nv::Int
+    graph::SimpleGraph{Int}
 end
-Coloring{K}(code::ET, nv::Int) where {K,ET<:AbstractEinsum} = Coloring{K,ET}(code, nv)
+Coloring{K}(code::ET, graph::SimpleGraph) where {K,ET<:AbstractEinsum} = Coloring{K,ET}(code, graph)
 # same network layout as independent set.
 function Coloring{K}(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing) where K
     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, nv(g))
+    Coloring{K}(code, g)
 end
 
 flavors(::Type{<:Coloring{K}}) where K = collect(0:K-1)
 get_weights(::Coloring{K}, i::Int) where K = ones(Int, K)
-terms(gp::Coloring) = getixsv(gp.code)[1:gp.nv]
-labels(gp::Coloring) = [1:gp.nv...]
+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 <= c.nv ? coloringv(T, K) .^ get_weights(c, i) : coloringb(x, K)
+        i <= nv(c.graph) ? coloringv(T, K) .^ get_weights(c, i) : coloringb(x, K)
     end, ixs, labels(c))
 end
 

src/networks/DominatingSet.jl

@@ -9,13 +9,14 @@ In the constructor, `weights` are the weights of vertices.
 """
 struct DominatingSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT
+    graph::SimpleGraph{Int}
     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)
+    DominatingSet(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), g, weights)
 end
 
 flavors(::Type{<:DominatingSet}) = [0, 1]

src/networks/IndependentSet.jl

@@ -10,7 +10,7 @@ In the constructor, `weights` are the weights of vertices.
 """
 struct IndependentSet{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT
-    nv::Int
+    graph::SimpleGraph{Int}
     weights::WT
 end
 
@@ -19,21 +19,21 @@ function IndependentSet(g::SimpleGraph; weights=NoWeight(), openvertices=(), opt
     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)
-    IndependentSet(code, nv(g), weights)
+    IndependentSet(code, g, weights)
 end
 
 flavors(::Type{<:IndependentSet}) = [0, 1]
 get_weights(gp::IndependentSet, i::Int) = [0, gp.weights[i]]
-terms(gp::IndependentSet) = getixsv(gp.code)[1:gp.nv]
-labels(gp::IndependentSet) = [1:gp.nv...]
+terms(gp::IndependentSet) = getixsv(gp.code)[1:nv(gp.graph)]
+labels(gp::IndependentSet) = [1:nv(gp.graph)...]
 
 # generate tensors
 function generate_tensors(x::T, gp::IndependentSet) where T
-    gp.nv == 0 && return []
+    nv(gp.graph) == 0 && return []
     ixs = getixsv(gp.code)
     # we only add labels at vertex tensors
-    return vcat(add_labels!([misv(Ref(x) .^ get_weights(gp, i)) for i=1:gp.nv], ixs[1:gp.nv], labels(gp)),
-            [misb(T, length(ix)) for ix in ixs[gp.nv+1:end]] # if n!=2, it corresponds to set packing problem.
+    return vcat(add_labels!([misv(Ref(x) .^ get_weights(gp, i)) for i=1:nv(gp.graph)], ixs[1:nv(gp.graph)], labels(gp)),
+            [misb(T, length(ix)) for ix in ixs[nv(gp.graph)+1:end]] # if n!=2, it corresponds to set packing problem.
     )
 end
 
@@ -70,7 +70,8 @@ julia> res = best_solutions(gp; all=true)[]
 function set_packing(sets; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     n = length(sets)
     code = EinCode(vcat([[i] for i=1:n], [[i,j] for i=1:n,j=1:n if j>i && !isempty(sets[i] ∩ sets[j])]), collect(Int,openvertices))
-    IndependentSet(_optimize_code(code, uniformsize(code, 2), optimizer, simplifier), n, weights)
+    # NOTE: we use a dummy graph here, which should be a hypergraph!
+    IndependentSet(_optimize_code(code, uniformsize(code, 2), optimizer, simplifier), SimpleGraph(n), weights)
 end
 
 """

src/networks/Matching.jl

@@ -7,29 +7,29 @@ The [Vertex matching](https://psychic-meme-f4d866f8.pages.github.io/dev/tutorial
 """
 struct Matching{CT<:AbstractEinsum} <: GraphProblem
     code::CT
-    ne::Int
+    graph::SimpleGraph{Int}
 end
 
 function Matching(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     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), length(edges))
+    Matching(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), g)
 end
 
 flavors(::Type{<:Matching}) = [0, 1]
 get_weights(::Matching, i::Int) = [0, 1]
-terms(gp::Matching) = getixsv(gp.code)[1:gp.ne]
+terms(gp::Matching) = getixsv(gp.code)[1:ne(gp.graph)]
 labels(gp::Matching) = getindex.(terms(gp))
 
 function generate_tensors(x::T, m::Matching) where T
-    m.ne == 0 && return []
+    ne(m.graph) == 0 && return []
     ixs = getixsv(m.code)
     tensors = AbstractArray{T}[]
     for i=1:length(ixs)
         ix = ixs[i]
-        if i<=m.ne
+        if i<=ne(m.graph)
             @assert length(ix) == 1
             t = Ref(x) .^ get_weights(m, i) # x is defined on edges.
         else

src/networks/MaxCut.jl

@@ -9,19 +9,19 @@ In the constructor, `weights` are the weights of edges.
 """
 struct MaxCut{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT
-    nv::Int
+    graph::SimpleGraph{Int}
     weights::WT
 end
 function MaxCut(g::SimpleGraph; weights=NoWeight(), openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     @assert weights isa NoWeight || length(weights) == ne(g)
     rawcode = EinCode([[minmax(e.src,e.dst)...] for e in Graphs.edges(g)], collect(Int, openvertices))  # labels for edge tensors
-    MaxCut(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), nv(g), weights)
+    MaxCut(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), g, weights)
 end
 
 flavors(::Type{<:MaxCut}) = [0, 1]
 get_weights(gp::MaxCut, i::Int) = [0, gp.weights[i]]
 terms(gp::MaxCut) = getixsv(gp.code)
-labels(gp::MaxCut) = [1:gp.nv...]
+labels(gp::MaxCut) = [1:nv(gp.graph)...]
 
 function generate_tensors(x::T, gp::MaxCut) where T
     ixs = getixsv(gp.code)

src/networks/MaximalIS.jl

@@ -8,13 +8,14 @@ The [maximal independent set](https://psychic-meme-f4d866f8.pages.github.io/dev/
 """
 struct MaximalIS{CT<:AbstractEinsum,WT<:Union{NoWeight, Vector}} <: GraphProblem
     code::CT
+    graph::SimpleGraph
     weights::WT
 end
 
 function MaximalIS(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))
-    MaximalIS(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), weights)
+    MaximalIS(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier), g, weights)
 end
 
 flavors(::Type{<:MaximalIS}) = [0, 1]

test/configurations.jl

@@ -32,7 +32,7 @@ end
 
 @testset "enumerating" begin
     rawcode = IndependentSet(smallgraph(:petersen); optimizer=nothing)
-    optcode = IndependentSet(optimize_code(rawcode.code, uniformsize(rawcode.code, 2), GreedyMethod()), 10, NoWeight())
+    optcode = IndependentSet(optimize_code(rawcode.code, uniformsize(rawcode.code, 2), GreedyMethod()), smallgraph(:petersen), NoWeight())
     for code in [rawcode, optcode]
         res0 = max_size(code)
         _, res1 = max_size_count(code)