update

Author: GiggleLiu

README.md

@@ -41,7 +41,7 @@ julia> using GraphTensorNetworks, Random, LightGraphs
 julia> graph = (Random.seed!(2); LightGraphs.smallgraph(:petersen))
 {10, 15} undirected simple Int64 graph
 
-julia> problem = Independence(graph; optmethod=:tree, sc_target=0, sc_weight=1.0, ntrials=10, βs=0.01:0.1:15.0, niters=20, rw_weight=0.2);
+julia> problem = Independence(graph; optimizer=TreeSA(sc_target=0, sc_weight=1.0, ntrials=10, βs=0.01:0.1:15.0, niters=20, rw_weight=0.2));
 ┌ Warning: target space complexity not found, got: 4.0, with time complexity 7.965784284662087, read-right complexity 8.661778097771988.
 └ @ OMEinsumContractionOrders ~/.julia/dev/OMEinsumContractionOrders/src/treesa.jl:71
 time/space complexity is (7.965784284662086, 4.0)

notebooks/tropicalwidget_simple.jl

@@ -50,7 +50,7 @@ graph = unitdisk_graph(locs, 0.23) # SimpleGraph
 vizconfig(graph; locs=locs, config=rand(Bool, 12), graphsize=8cm)
 
 # ╔═╡ e068f0b8-7b2c-49b2-94d1-83dead406326
-gp = Independence(graph; outputs=(1,2,3,4), optmethod=:greedy)
+gp = Independence(graph; outputs=(1,2,3,4))
 
 # ╔═╡ 90c88c7f-e0c7-4845-a8b9-7f7562bd256f
 solve(gp, :config_single)

notebooks/tutorial.jl

@@ -24,7 +24,7 @@ g = unitdisk_graph(locs, 0.2)
 vizconfig(g; locs=locs, unit=0.5)
 
 # ╔═╡ b6e916e2-7d43-4085-a3c8-5c57069e8384
-gp = Independence(g; optmethod=:auto);
+gp = Independence(g, optimizer=TreeSA());
 
 # ╔═╡ 1a58dea3-14fa-4be7-b087-45ed9bad2407
 gp

src/GraphTensorNetworks.jl

@@ -8,6 +8,7 @@ using OMEinsum: timespace_complexity, collect_ixs
 using LightGraphs
 
 export timespace_complexity, @ein_str
+export GreedyMethod, TreeSA, SABipartite, KaHyParBipartite, MergeVectors, MergeGreedy
 
 project_relative_path(xs...) = normpath(joinpath(dirname(dirname(pathof(@__MODULE__))), xs...))
 

src/networks.jl

@@ -5,55 +5,59 @@ abstract type GraphProblem end
 
 """
     Independence{CT<:EinTypes} <: GraphProblem
-    Independence(graph; openvertices=(), optmethod=:greedy, kwargs...)
+    Independence(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
-Independent set problem. `kwargs` is forwarded to `optimize_code`.
+Independent set problem. `openvertices` specifies the output tensor.
+`optimizer` and `simplifier` are for tensor network optimization, check `optimize_code` for details.
 """
 struct Independence{CT<:EinTypes} <: GraphProblem
     code::CT
 end
 
-function Independence(g::SimpleGraph; openvertices=(), optmethod=:greedy, kwargs...)
+function Independence(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     rawcode = EinCode(([(i,) for i in LightGraphs.vertices(g)]..., # labels for vertex tensors
                     [minmax(e.src,e.dst) for e in LightGraphs.edges(g)]...), openvertices)  # labels for edge tensors
-    code = optimize_code(rawcode, Val(optmethod); kwargs...)
+    code = _optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier)
     Independence(code)
 end
 
 """
     MaxCut{CT<:EinTypes} <: GraphProblem
-    MaxCut(graph; openvertices=(), optmethod=:greedy, kwargs...)
+    MaxCut(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
-Max cut problem (or spin glass problem). `kwargs` is forwarded to `optimize_code`.
+Max cut problem (or spin glass problem).
+`optimizer` and `simplifier` are for tensor network optimization, check `optimize_code` for details.
 """
 struct MaxCut{CT<:EinTypes} <: GraphProblem
     code::CT
 end
-function MaxCut(g::SimpleGraph; openvertices=(), optmethod=:greedy, kwargs...)
+function MaxCut(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     rawcode = EinCode(([minmax(e.src,e.dst) for e in LightGraphs.edges(g)]...,), openvertices)  # labels for edge tensors
-    MaxCut(optimize_code(rawcode, Val(optmethod); kwargs...))
+    MaxCut(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier))
 end
 
 """
     MaximalIndependence{CT<:EinTypes} <: GraphProblem
-    MaximalIndependence(graph; openvertices=(), optmethod=:greedy, kwargs...)
+    MaximalIndependence(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
-Maximal independent set problem. `kwargs` is forwarded to `optimize_code`.
+Maximal independent set problem. 
+`optimizer` and `simplifier` are for tensor network optimization, check `optimize_code` for details.
 """
 struct MaximalIndependence{CT<:EinTypes} <: GraphProblem
     code::CT
 end
 
-function MaximalIndependence(g::SimpleGraph; openvertices=(), optmethod=:greedy, kwargs...)
+function MaximalIndependence(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     rawcode = EinCode(([(LightGraphs.neighbors(g, v)..., v) for v in LightGraphs.vertices(g)]...,), openvertices)
-    MaximalIndependence(optimize_code(rawcode, Val(optmethod); kwargs...))
+    MaximalIndependence(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier))
 end
 
 """
     Matching{CT<:EinTypes} <: GraphProblem
-    Matching(graph; openvertices=(), optmethod=:greedy, kwargs...)
+    Matching(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
-Vertex matching problem. `kwargs` is forwarded to `optimize_code`.
+Vertex matching problem.
+`optimizer` and `simplifier` are for tensor network optimization, check `optimize_code` for details.
 The matching polynomial adopts the first definition in wiki page: https://en.wikipedia.org/wiki/Matching_polynomial
 ```math
 m_G(x) := \\sum_{k\\geq 0}m_kx^k,
@@ -64,24 +68,25 @@ struct Matching{CT<:EinTypes} <: GraphProblem
     code::CT
 end
 
-function Matching(g::SimpleGraph; openvertices=(), optmethod=:greedy, kwargs...)
+function Matching(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     rawcode = EinCode(([(minmax(e.src,e.dst),) for e in LightGraphs.edges(g)]..., # labels for edge tensors
                     [([minmax(i,j) for j in neighbors(g, i)]...,) for i in LightGraphs.vertices(g)]...,), openvertices)       # labels for vertex tensors
-    Matching(optimize_code(rawcode, Val(optmethod); kwargs...))
+    Matching(_optimize_code(rawcode, uniformsize(rawcode, 2), optimizer, simplifier))
 end
 
 """
     Coloring{K,CT<:EinTypes} <: GraphProblem
-    Coloring{K}(graph; openvertices=(), optmethod=:greedy, kwargs...)
+    Coloring{K}(graph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
-K-Coloring problem. `kwargs` is forwarded to `optimize_code`.
+K-Coloring problem.
+`optimizer` and `simplifier` are for tensor network optimization, check `optimize_code` for details.
 """
 struct Coloring{K,CT<:EinTypes} <: GraphProblem
     code::CT
 end
 Coloring{K}(code::ET) where {K,ET<:EinTypes} = Coloring{K,ET}(code)
 # same network layout as independent set.
-Coloring{K}(g::SimpleGraph; openvertices=(), optmethod=:greedy, kwargs...) where K = Coloring{K}(Independence(g; openvertices=openvertices, optmethod=optmethod, D=K, kwargs...).code)
+Coloring{K}(g::SimpleGraph; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing) where K = Coloring{K}(Independence(g; openvertices=openvertices, optimizer=optimizer, simplifier=simplifier).code)
 
 """
     labels(code)
@@ -100,44 +105,6 @@ function labels(code::EinTypes)
     return res
 end
 
-"""
-    optimize_code(code; optmethod=:kahypar, sc_target=17, max_group_size=40, nrepeat=10, imbalances=0.0:0.001:0.8, βs=0.01:0.05:10.0, ntrials=50, niters=1000, sc_weight=2.0, rw_weight=1.0)
-
-Optimize the contraction order.
-
-* `optmethod` can be one of
-    * `:kahypar`, the kahypar + greedy approach, takes kwargs [`sc_target`, `max_group_size`, `imbalances`, `nrepeat`].
-    Check `optimize_kahypar` method in package `OMEinsumContractionOrders`.
-    * `:auto`, also the kahypar + greedy approach, but determines `sc_target` automatically. It is slower!
-    * `:greedy`, the greedy approach. Check `optimize_greedy` in package `OMEinsum`.
-    * `:tree`, the approach of running simulated annealing on expression tree, takes kwargs [`sc_target`, `sc_weight`, `rw_weight`, `βs`, `ntrials`, `niters`]. Check `optimize_tree` in package `OMEinsumContractionOrders`.
-    * `:sa`, the simulated annealing approach, takes kwargs [`rw_weight`, `βs`, `ntrials`, `niters`]. Check `optimize_sa` in package `OMEinsumContractionOrders`.
-    * `:raw`, do nothing and return the raw EinCode.
-"""
-function optimize_code(@nospecialize(code::EinTypes), ::Val{optmethod}; sc_target=17, max_group_size=40, nrepeat=10, imbalances=0.0:0.001:0.8, initializer=:random, βs=0.01:0.05:10.0, ntrials=50, niters=1000, sc_weight=2.0, rw_weight=1.0, D=2) where optmethod
-    if optmethod === :raw
-        return code
-    end
-    size_dict = Dict([s=>D for s in labels(code)])
-    simplifier, code = merge_vectors(code)
-    optcode = if optmethod === :kahypar
-        optimize_kahypar(code, size_dict; sc_target=sc_target, max_group_size=max_group_size, imbalances=imbalances, greedy_nrepeat=nrepeat)
-    elseif optmethod === :sa
-        optimize_sa(code, size_dict; sc_target=sc_target, max_group_size=max_group_size, βs=βs, ntrials=ntrials, niters=niters, initializer=initializer, greedy_nrepeat=nrepeat)
-    elseif optmethod === :greedy
-        optimize_greedy(code, size_dict; nrepeat=nrepeat)
-    elseif optmethod === :tree
-        optimize_tree(code, size_dict; sc_target=sc_target, βs=βs, niters=niters, ntrials=ntrials, sc_weight=sc_weight, initializer=initializer, rw_weight=rw_weight)
-    elseif optmethod === :auto
-        optimize_kahypar_auto(code, size_dict; max_group_size=max_group_size, effort=500, greedy_nrepeat=nrepeat)
-    else
-        ArgumentError("optimizer `$optmethod` not defined.")
-    end
-    optcode = embed_simplifier(optcode, simplifier)
-    @info "time/space complexity is $(OMEinsum.timespace_complexity(optcode, size_dict))"
-    return optcode
-end
-
 OMEinsum.timespace_complexity(gp::GraphProblem) = timespace_complexity(gp.code, uniformsize(gp.code, bondsize(gp)))
 
 for T in [:Independence, :Matching, :MaximalIndependence, :MaxCut]
@@ -146,25 +113,28 @@ end
 bondsize(gp::Coloring{K}) where K = K
 
 """
-set_packing(sets; openvertices=(), optmethod=:greedy, kwargs...)
+set_packing(sets; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
 
 Set packing is a generalization of independent set problem to hypergraphs.
 Calling this function will return you an `Independence` instance.
 `sets` are a vector of vectors, each element being a vertex in the independent set problem.
-`kwargs` is forwarded to `optimize_code`.
+`optimizer` and `simplifier` are for tensor network optimization, check `optimize_code` for details.
 
 ### Example
 ```julia
 julia> sets = [[1, 2, 5], [1, 3], [2, 4], [3, 6], [2, 3, 6]];  # each set is a vertex
 
-julia> gp = set_packing(sets; optmethod=:auto);
+julia> gp = set_packing(sets);
 
 julia> res = best_solutions(gp; all=true)[]
 (2, {10010, 00110, 01100})ₜ
 ```
 """
-function set_packing(sets; openvertices=(), optmethod=:greedy, kwargs...)
+function set_packing(sets; openvertices=(), optimizer=GreedyMethod(), simplifier=nothing)
     n = length(sets)
     code = EinCode(([(i,) for i=1:n]..., [(i,j) for i=1:n,j=1:n if j>i && !isempty(sets[i] ∩ sets[j])]...), openvertices)
-    Independence(optimize_code(code, Val(optmethod); kwargs...))
+    Independence(_optimize_code(code, uniformsize(code, 2), optimizer, simplifier))
 end
+
+_optimize_code(code, size_dict, optimizer::Nothing, simplifier) = code
+_optimize_code(code, size_dict, optimizer, simplifier) = optimize_code(code, size_dict, optimizer, simplifier)

test/bounding.jl

@@ -22,8 +22,8 @@ end
         y2 = bounding_contract(code, xs, BitArray(ones(Bool,2,2,2)), xs)
         @test y1 ≈ y2
     end
-    rawcode = Independence(random_regular_graph(10, 3); optmethod=:raw).code
-    optcode = Independence(random_regular_graph(10, 3); optmethod=:greedy).code
+    rawcode = Independence(random_regular_graph(10, 3); optimizer=nothing).code
+    optcode = Independence(random_regular_graph(10, 3); optimizer=GreedyMethod()).code
     xs = map(OMEinsum.getixs(rawcode)) do ix
         length(ix)==1 ? GraphTensorNetworks.misv(TropicalF64(1.0)) : GraphTensorNetworks.misb(TropicalF64)
     end

test/configurations.jl

@@ -29,8 +29,8 @@ using TropicalNumbers: CountingTropicalF64
 end
 
 @testset "enumerating" begin
-    rawcode = Independence(random_regular_graph(10, 3); optmethod=:raw)
-    optcode = Independence(optimize_code(rawcode.code, Val(:greedy)))
+    rawcode = Independence(random_regular_graph(10, 3); optimizer=nothing)
+    optcode = Independence(optimize_code(rawcode.code, uniformsize(rawcode.code, 2), GreedyMethod()))
     for code in [rawcode, optcode]
         res0 = max_size(code)
         _, res1 = max_size_count(code)
@@ -58,7 +58,7 @@ end
 
 @testset "set packing" begin
     sets = [[1, 2, 5], [1, 3], [2, 4], [3, 6], [2, 3, 6]]  # each set is a vertex
-    gp = set_packing(sets; optmethod=:auto)
+    gp = set_packing(sets; optimizer=GreedyMethod())
     res = best_solutions(gp; all=true)[]
     @test res.n == 2
     @test BitVector(Bool[0,0,1,1,0]) ∈ res.c.data
@@ -71,7 +71,7 @@ end
     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)
+    code = MaxCut(g; optimizer=GreedyMethod())
     res = best_solutions(code; all=true)[]
     @test length(res.c.data) == 2
     @test sum(res.c.data[1]) == 5
@@ -82,18 +82,18 @@ end
     for (i,j) in [(1,2),(2,3),(3,4),(4,1),(1,5),(2,4)]
         add_edge!(g, i, j)
     end
-    code = Coloring{3}(g; optmethod=:greedy)
+    code = Coloring{3}(g; optimizer=GreedyMethod())
     res = solutions(code, CountingTropicalF64; all=true)[]
     @test length(res.c.data) == 12
     g = smallgraph(:petersen)
-    code = Coloring{3}(g; optmethod=:greedy)
+    code = Coloring{3}(g; optimizer=GreedyMethod())
     res = solutions(code, CountingTropicalF64; all=true)[]
     @test length(res.c.data) == 120
 end
 
 @testset "enumerating - matching" begin
     g = smallgraph(:petersen)
-    code = Matching(g; optmethod=:greedy)
+    code = Matching(g; optimizer=GreedyMethod())
     res = solutions(code, CountingTropicalF64; all=true)[]
     @test res.n == 5
     @test length(res.c.data) == 6

test/graph_polynomials.jl

@@ -46,11 +46,11 @@ end
 
 @testset "counting maximal IS" begin
     g = random_regular_graph(20, 3)
-    gp = MaximalIndependence(g, optmethod=:kahypar)
+    gp = MaximalIndependence(g, optimizer=KaHyParBipartite(sc_target=20))
     cs = graph_polynomial(gp, Val(:fft); r=1.0)[]
-    gp = MaximalIndependence(g, optmethod=:sa)
+    gp = MaximalIndependence(g, optimizer=SABipartite(sc_target=20))
     cs2 = graph_polynomial(gp, Val(:polynomial))[]
-    gp = MaximalIndependence(g, optmethod=:greedy)
+    gp = MaximalIndependence(g, optimizer=GreedyMethod())
     cs3 = graph_polynomial(gp, Val(:finitefield))[]
     cg = complement(g)
     cliques = maximal_cliques(cg)

test/interfaces.jl

@@ -3,7 +3,7 @@ using LightGraphs, Test
 
 @testset "independence problem" begin
     g = LightGraphs.smallgraph("petersen")
-    gp = Independence(g; optmethod=:greedy)
+    gp = Independence(g; optimizer=GreedyMethod())
     res1 = solve(gp, "size max")[]
     res2 = solve(gp, "counting sum")[]
     res3 = solve(gp, "counting max")[]