various changes

Author: samuelsonric

src/OMEinsumContractionOrders.jl

@@ -13,7 +13,7 @@ import CliqueTrees
 using CliqueTrees: cliquetree, residual, EliminationAlgorithm, MMW, BFS, MCS, LexBFS, RCMMD, RCMGL, MCSM, LexM, AMF, MF, MMD, MF, BT, SafeRules
 
 export CodeOptimizer, CodeSimplifier,
-    KaHyParBipartite, GreedyMethod, TreeSA, SABipartite, Treewidth, ExactTreewidth,
+    KaHyParBipartite, GreedyMethod, TreeSA, SABipartite, Treewidth, ExactTreewidth, Reduction
     MergeGreedy, MergeVectors,
     uniformsize,
     simplify_code, optimize_code, optimize_permute,

src/interfaces.jl

@@ -55,7 +55,7 @@ function _optimize_code(code, size_dict, optimizer::TreeSA)
         sc_weight=optimizer.sc_weight, rw_weight=optimizer.rw_weight, initializer=optimizer.initializer,
         greedy_method=optimizer.greedy_config, fixed_slices=optimizer.fixed_slices)
 end
-function _optimize_code(code, size_dict, optimizer::Reduction)
-    _optimizer = Treewidth(; alg=ReductionEA(optimizer.inner))
+function _optimize_code(code, size_dict, optimizer::Reduction{S}) where {S}
+    _optimizer = Treewidth(; alg=ReductionEA{S}(optimizer.inner))
     _optimize_code(code, size_dict, _optimizer)
 end

src/reduction.jl

@@ -1,45 +1,97 @@
-struct Reduction{O <: CodeOptimizer} <: CodeOptimizer
+struct Reduction{S, O <: CodeOptimizer} <: CodeOptimizer
     inner::O
 end
 
-struct ReductionEA{O <: CodeOptimizer} <: CliqueTrees.EliminationAlgorithm
+function Reduction{S}(inner::O) where {O <: CodeOptimizer}
+    return Reduction{S, O}(inner)
+end
+
+function Reduction(inner::CodeOptimizer)
+    return Reduction{3}(inner)
+end
+
+struct ReductionEA{S, O <: CodeOptimizer} <: CliqueTrees.EliminationAlgorithm
     inner::O
 end
 
-#=
-function CliqueTrees.permutation(weights::AbstractVector, graph, alg::ReductionEA)
+function ReductionEA{S}(inner::O) where {O <: CodeOptimizer}
+    return ReductionEA{S, O}(inner)
+end
+
+# rules applied:
+#  - islet
+#  - twig
+#  - series
+#  - triangle
+#  - buddy
+#  - cube
+function CliqueTrees.permutation(weights::AbstractVector, graph, alg::ReductionEA{1})
     # reduce graph
     width = CliqueTrees.lowerbound(weights, graph)
-    weights, graph, stack, index, width = CliqueTrees.saferules(weights, graph, width)
+    graph, stack, label, width = CliqueTrees.pr3(weights, graph, width)
 
     # feed reduced graph back to OMEinsumContractionOrders
-    code = EinCode(maximal_cliques(CliqueTrees.Graph(graph)), Int[])
-    sizes = Dict{Int, Int}(v => round(Int, 2^weights[v]) for v in CliqueTrees.vertices(graph))
+    code = EinCode(maximal_cliques(graph), Int[])
+    sizes = Dict{Int, Int}(v => round(Int, 2^weights[label[v]]) for v in CliqueTrees.vertices(graph))
     opt = optimize_code(code, sizes, alg.inner).eins
-
-    # compute ordering
-    for v in eincode2order(opt)
-        append!(stack, CliqueTrees.neighbors(index, v))
-    end
 
+    # compute ordering
+    append!(stack, label[eincode2order(opt)])
     return stack, invperm(stack)
 end
-=#
 
-function CliqueTrees.permutation(weights::AbstractVector, graph, alg::ReductionEA)
+# rules applied:
+#  - islet
+#  - twig
+#  - series
+#  - triangle
+#  - buddy
+#  - cube
+#  - simplicial
+#  - almost-simplicial
+function CliqueTrees.permutation(weights::AbstractVector, graph, alg::ReductionEA{2})
     # reduce graph
-    kernel, stack, label, width = CliqueTrees.pr4(graph, CliqueTrees.lowerbound(graph))
+    width = CliqueTrees.lowerbound(weights, graph)
+    graph, stack, label, width = CliqueTrees.pr4(graph, weights)
 
     # feed reduced graph back to OMEinsumContractionOrders
-    code = EinCode(maximal_cliques(kernel), Int[])
-    sizes = Dict{Int, Int}(v => round(Int, 2^weights[label[v]]) for v in CliqueTrees.vertices(kernel))
+    code = EinCode(maximal_cliques(graph), Int[])
+    sizes = Dict{Int, Int}(v => round(Int, 2^weights[label[v]]) for v in CliqueTrees.vertices(graph))
     opt = optimize_code(code, sizes, alg.inner).eins
 
     # compute ordering
     append!(stack, label[eincode2order(opt)])
     return stack, invperm(stack)
 end
 
+# rules applied:
+#  - islet
+#  - twig
+#  - series
+#  - triangle
+#  - buddy
+#  - cube
+#  - simplicial
+#  - almost-simplicial
+#  - indistinguishable neighbors
+function CliqueTrees.permutation(weights::AbstractVector, graph, alg::ReductionEA{3})
+    # reduce graph
+    width = CliqueTrees.lowerbound(weights, graph)
+    weights, graph, stack, index, width = CliqueTrees.saferules(weights, graph, width)
+    
+    # feed reduced graph back to OMEinsumContractionOrders
+    code = EinCode(maximal_cliques(CliqueTrees.Graph(graph)), Int[])
+    sizes = Dict{Int, Int}(v => round(Int, 2^weights[v]) for v in CliqueTrees.vertices(graph))
+    opt = optimize_code(code, sizes, alg.inner).eins
+
+    # compute ordering
+    for v in eincode2order(opt)
+        append!(stack, CliqueTrees.neighbors(index, v))
+    end
+    
+    return stack, invperm(stack)
+end
+
 function eincode2order(code::NestedEinsum{L}) where {L}
     elimination_order = Vector{L}()
     isleaf(code) && return elimination_order