Max Cut

Author: GiggleLiu

src/bitvector.jl

@@ -44,3 +44,4 @@ function Base.iterate(x::StaticBitVector{N,C}, state=1) where {N,C}
     end
 end
 
+Base.show(io::IO, t::StaticBitVector) = Base.print(io, "$(join(Int.(t), ""))")

src/configurations.jl

@@ -12,8 +12,8 @@ function optimalsolutions(gp::GraphProblem; all=false, usecuda=false)
     if all && usecuda
         throw(ArgumentError("ConfigEnumerator can not be computed on GPU!"))
     end
-    T = (all ? bitstringset_type : bitstringsampler_type)(CountingTropical{Int64}, length(labels(gp.code)))
-    syms = labels(gp.code)
+    syms = symbols(gp)
+    T = (all ? bitstringset_type : bitstringsampler_type)(CountingTropical{Int64}, length(syms))
     vertex_index = Dict([s=>i for (i, s) in enumerate(syms)])
     xst = generate_tensors(l->TropicalF64(1.0), gp)
     ymask = trues(fill(2, length(OMEinsum.getiy(flatten(gp.code))))...)
@@ -53,7 +53,13 @@ end
 
 # return a mapping from label to variable `x`
 function fx_solutions(gp::GraphProblem, ::Type{BT}, all::Bool) where BT
-    T = (all ? bitstringset_type : bitstringsampler_type)(BT, length(labels(gp.code)))
-    vertex_index = Dict([s=>i for (i, s) in enumerate(labels(gp.code))])
+    syms = symbols(gp)
+    T = (all ? bitstringset_type : bitstringsampler_type)(BT, length(syms))
+    vertex_index = Dict([s=>i for (i, s) in enumerate(syms)])
     return l->onehotv(T, vertex_index[l])
-end
+end
+for GP in [:Independence, :Matching, :MaximalIndependence]
+    @eval symbols(gp::$GP) = labels(gp.code)
+end
+symbols(gp::MaxCut) = collect(OMEinsum.getixs(OMEinsum.flatten(gp.code)))
+# TODO: coloring

src/graph_polynomials.jl

@@ -197,23 +197,16 @@ end
 
 graph_polynomial_maxorder(mi::MaximalIndependence; usecuda) = Int(sum(contractx(mi, TropicalF64(1.0); usecuda=usecuda)).n)
 
-### spin glass problem ###
-function generate_tensors(fx, gp::SpinGlass{2})
+### max cut/spin glass problem ###
+function generate_tensors(fx, gp::MaxCut)
     flatten_code = flatten(gp.code)
     ixs = getixs(flatten_code)
-    n = length(labels(flatten_code))
-    T = typeof(fx(ixs[1][1]))
     return Tuple(map(enumerate(ixs)) do (i, ix)
-        if i <= n
-            spinglassv(one(T))
-        else
-            spinglassb(fx(ix)) # if n!=2, it corresponds to set packing problem.
-        end
+        maxcutb(fx(ix)) # if n!=2, it corresponds to set packing problem.
     end)
 end
-function spinglassb(expJ::T) where T
+function maxcutb(expJ::T) where T
     return T[one(T) expJ; expJ one(T)]
 end
-spinglassv(h::T) where T = T[one(T), h]
 
-graph_polynomial_maxorder(mi::SpinGlass; usecuda) = Int(sum(contractx(mi, TropicalF64(1.0); usecuda=usecuda)).n)
+graph_polynomial_maxorder(mi::MaxCut; usecuda) = Int(sum(contractx(mi, TropicalF64(1.0); usecuda=usecuda)).n)

src/networks.jl

@@ -1,4 +1,4 @@
-export Independence, MaximalIndependence, Matching, Coloring, optimize_code, set_packing, SpinGlass
+export Independence, MaximalIndependence, Matching, Coloring, optimize_code, set_packing, MaxCut
 const EinTypes = Union{EinCode,NestedEinsum}
 
 abstract type GraphProblem end
@@ -20,20 +20,18 @@ function Independence(g::SimpleGraph; outputs=(), kwargs...)
 end
 
 """
-    SpinGlass{Q, CT<:EinTypes} <: GraphProblem
-    SpinGlass{Q}(graph; kwargs...)
-    SpinGlass(graph; kwargs...)
+    MaxCut{CT<:EinTypes} <: GraphProblem
+    MaxCut(graph; kwargs...)
 
-Q-state spin glass problem (or Potts model). For `kwargs`, check `optimize_code` API.
-When Q=2, it corresponds to the {0, 1} spin glass model.
+Max cut problem (or spin glass problem). For `kwargs`, check `optimize_code` API.
 """
-struct SpinGlass{Q, CT<:EinTypes} <: GraphProblem
+struct MaxCut{CT<:EinTypes} <: GraphProblem
     code::CT
 end
-
-SpinGlass(g::SimpleGraph; outputs=(), kwargs...) = SpinGlass{2}(g; outputs=outputs, kwargs...)
-SpinGlass{Q}(g::SimpleGraph; outputs=(), kwargs...) where Q = SpinGlass{Q}(Independence(g; outputs=outputs, kwargs...).code)
-SpinGlass{Q}(code::EinTypes) where Q = SpinGlass{Q,typeof(code)}(code)
+function MaxCut(g::SimpleGraph; outputs=(), kwargs...)
+    rawcode = EinCode(([minmax(e.src,e.dst) for e in LightGraphs.edges(g)]...,), outputs)  # labels for edge tensors
+    MaxCut(optimize_code(rawcode; kwargs...))
+end
 
 """
     MaximalIndependence{CT<:EinTypes} <: GraphProblem
@@ -127,11 +125,10 @@ end
 
 OMEinsum.timespace_complexity(gp::GraphProblem) = timespace_complexity(gp.code, uniformsize(gp.code, bondsize(gp)))
 
-for T in [:Independence, :Matching, :MaximalIndependence]
+for T in [:Independence, :Matching, :MaximalIndependence, :MaxCut]
     @eval bondsize(gp::$T) = 2
 end
 bondsize(gp::Coloring{K}) where K = K
-bondsize(gp::SpinGlass{Q}) where Q = Q
 
 """
     set_packing(sets; kwargs...)

test/configurations.jl

@@ -52,4 +52,15 @@ end
     @test BitVector(Bool[0,0,1,1,0]) ∈ res.c.data
     @test BitVector(Bool[1,0,0,1,0]) ∈ res.c.data
     @test BitVector(Bool[0,1,1,0,0]) ∈ res.c.data
+end
+
+@testset "enumerating - max cut" begin
+    g = SimpleGraph(5)
+    for (i,j) in [(1,2),(2,3),(3,4),(4,1),(1,5),(2,4)]
+        add_edge!(g, i, j)
+    end
+    code = MaxCut(g; optmethod=:greedy)
+    res = optimalsolutions(code; all=true)[]
+    @test length(res.c.data) == 2
+    @test sum(res.c.data[1]) == 5
 end

test/graph_polynomials.jl

@@ -74,6 +74,6 @@ end
     for (i,j) in [(1,2),(2,3),(3,4),(4,1),(1,5),(2,4)]
         add_edge!(g, i, j)
     end
-    @test graph_polynomial(SpinGlass{2}, Val(:polynomial), g)[] == Polynomial([2,2,4,12,10,2])
-    @test graph_polynomial(SpinGlass{2}, Val(:finitefield), g)[] == Polynomial([2,2,4,12,10,2])
+    @test graph_polynomial(MaxCut, Val(:polynomial), g)[] == Polynomial([2,2,4,12,10,2])
+    @test graph_polynomial(MaxCut, Val(:finitefield), g)[] == Polynomial([2,2,4,12,10,2])
 end