upgrade omeinsum

Project.toml

@@ -1,7 +1,7 @@
 name = "GenericTensorNetworks"
 uuid = "3521c873-ad32-4bb4-b63d-f4f178f42b49"
 authors = ["GiggleLiu <cacate0129@gmail.com> and contributors"]
-version = "1.2.0"
+version = "1.2.1"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -14,7 +14,6 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LuxorGraphPlot = "1f49bdf2-22a7-4bc4-978b-948dc219fbbc"
 Mods = "7475f97c-0381-53b1-977b-4c60186c8d62"
 OMEinsum = "ebe7aa44-baf0-506c-a96f-8464559b3922"
-OMEinsumContractionOrders = "6f22d1fd-8eed-4bb7-9776-e7d684900715"
 Polynomials = "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
 Primes = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
@@ -26,14 +25,13 @@ StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 TropicalNumbers = "b3a74e9c-7526-4576-a4eb-79c0d4c32334"
 
 [compat]
-AbstractTrees = "0.3, 0.4"
+AbstractTrees = "0.4"
 CUDA = "3"
 FFTW = "1.4"
 Graphs = "1.7"
 LuxorGraphPlot = "0.1"
 Mods = "1.3"
-OMEinsum = "0.6.1"
-OMEinsumContractionOrders = "0.6"
+OMEinsum = "0.7"
 Polynomials = "2.0, 3"
 Primes = "0.5"
 Requires = "1"

docs/make.jl

@@ -1,6 +1,6 @@
 using Pkg
 using GenericTensorNetworks
-using GenericTensorNetworks: TropicalNumbers, Polynomials, Mods, OMEinsum, OMEinsumContractionOrders, LuxorGraphPlot
+using GenericTensorNetworks: TropicalNumbers, Polynomials, Mods, OMEinsum, OMEinsum.OMEinsumContractionOrders, LuxorGraphPlot
 using Documenter
 using DocThemeIndigo
 using PlutoStaticHTML

docs/src/gist.md

@@ -13,7 +13,7 @@ They can be installed in a similar way to `GenericTensorNetworks`.
 After installing the required packages, one can open a Julia REPL, and copy-paste the following code snippet into it.
 
 ```julia
-using OMEinsum, OMEinsumContractionOrders
+using OMEinsum
 using Graphs
 using Random
 

src/GenericTensorNetworks.jl

@@ -1,6 +1,5 @@
 module GenericTensorNetworks
 
-using OMEinsumContractionOrders
 using Core: Argument
 using TropicalNumbers
 using OMEinsum

src/bounding.jl

@@ -64,11 +64,11 @@ function cached_einsum(se::SlicedEinsum, @nospecialize(xs), size_dict)
 end
 function cached_einsum(code::NestedEinsum, @nospecialize(xs), size_dict)
     if OMEinsum.isleaf(code)
-        y = xs[code.tensorindex]
+        y = xs[OMEinsum.tensorindex(code)]
         return CacheTree(y, CacheTree{eltype(y)}[])
     else
-        caches = [cached_einsum(arg, xs, size_dict) for arg in code.args]
-        y = einsum(code.eins, ntuple(i->caches[i].content, length(caches)), size_dict)
+        caches = [cached_einsum(arg, xs, size_dict) for arg in OMEinsum.siblings(code)]
+        y = einsum(OMEinsum.rootcode(code), ntuple(i->caches[i].content, length(caches)), size_dict)
         return CacheTree(y, caches)
     end
 end
@@ -84,8 +84,9 @@ function generate_masktree(mode, code::NestedEinsum, cache, mask, size_dict)
     if OMEinsum.isleaf(code)
         return CacheTree(mask, CacheTree{Bool}[])
     else
-        submasks = backward_tropical(mode, getixs(code.eins), (getfield.(cache.siblings, :content)...,), OMEinsum.getiy(code.eins), cache.content, mask, size_dict)
-        return CacheTree(mask, generate_masktree.(Ref(mode), code.args, cache.siblings, submasks, Ref(size_dict)))
+        eins = OMEinsum.rootcode(code)
+        submasks = backward_tropical(mode, getixs(eins), (getfield.(cache.siblings, :content)...,), OMEinsum.getiy(eins), cache.content, mask, size_dict)
+        return CacheTree(mask, generate_masktree.(Ref(mode), OMEinsum.siblings(code), cache.siblings, submasks, Ref(size_dict)))
     end
 end
 
@@ -98,12 +99,12 @@ function masked_einsum(se::SlicedEinsum, @nospecialize(xs), masks, size_dict)
 end
 function masked_einsum(code::NestedEinsum, @nospecialize(xs), masks, size_dict)
     if OMEinsum.isleaf(code)
-        y = copy(xs[code.tensorindex])
+        y = copy(xs[OMEinsum.tensorindex(code)])
         y[OMEinsum.asarray(.!masks.content)] .= Ref(zero(eltype(y)))
         return y
     else
-        xs = [masked_einsum(arg, xs, mask, size_dict) for (arg, mask) in zip(code.args, masks.siblings)]
-        y = einsum(code.eins, (xs...,), size_dict)
+        xs = [masked_einsum(arg, xs, mask, size_dict) for (arg, mask) in zip(OMEinsum.siblings(code), masks.siblings)]
+        y = einsum(OMEinsum.rootcode(code), (xs...,), size_dict)
         y[OMEinsum.asarray(.!masks.content)] .= Ref(zero(eltype(y)))
         return y
     end
@@ -121,10 +122,10 @@ Contraction method with bounding.
 """
 function bounding_contract(mode::AllConfigs, code::EinCode, @nospecialize(xsa), ymask, @nospecialize(xsb); size_info=nothing)
     LT = OMEinsum.labeltype(code)
-    bounding_contract(mode, NestedEinsum(NestedEinsum{DynamicEinCode{LT}}.(1:length(xsa)), code), xsa, ymask, xsb; size_info=size_info)
+    bounding_contract(mode, DynamicNestedEinsum(DynamicNestedEinsum{LT}.(1:length(xsa)), code), xsa, ymask, xsb; size_info=size_info)
 end
 function bounding_contract(mode::AllConfigs, code::Union{NestedEinsum,SlicedEinsum}, @nospecialize(xsa), ymask, @nospecialize(xsb); size_info=nothing)
-    size_dict = size_info===nothing ? Dict{OMEinsum.labeltype(code.eins),Int}() : copy(size_info)
+    size_dict = size_info===nothing ? Dict{OMEinsum.labeltype(code),Int}() : copy(size_info)
     OMEinsum.get_size_dict!(code, xsa, size_dict)
     # compute intermediate tensors
     @debug "caching einsum..."
@@ -139,11 +140,11 @@ end
 # get the optimal solution with automatic differentiation.
 function solution_ad(code::EinCode, @nospecialize(xsa), ymask; size_info=nothing)
     LT = OMEinsum.labeltype(code)
-    solution_ad(NestedEinsum(NestedEinsum{DynamicEinCode{LT}}.(1:length(xsa)), code), xsa, ymask; size_info=size_info)
+    solution_ad(DynamicNestedEinsum(DynamicNestedEinsum{LT}.(1:length(xsa)), code), xsa, ymask; size_info=size_info)
 end
 
 function solution_ad(code::Union{NestedEinsum,SlicedEinsum}, @nospecialize(xsa), ymask; size_info=nothing)
-    size_dict = size_info===nothing ? Dict{OMEinsum.labeltype(code.eins),Int}() : copy(size_info)
+    size_dict = size_info===nothing ? Dict{OMEinsum.labeltype(code),Int}() : copy(size_info)
     OMEinsum.get_size_dict!(code, xsa, size_dict)
     # compute intermediate tensors
     @debug "caching einsum..."
@@ -165,7 +166,7 @@ function read_config!(code::SlicedEinsum, mt, out)
 end
 
 function read_config!(code::NestedEinsum, mt, out)
-    for (arg, ix, sibling) in zip(code.args, getixs(code.eins), mt.siblings)
+    for (arg, ix, sibling) in zip(OMEinsum.siblings(code), getixs(OMEinsum.rootcode(code)), mt.siblings)
         if OMEinsum.isleaf(arg)
             mask = convert(Array, sibling.content)  # note: the content can be CuArray
             for ci in CartesianIndices(mask)

test/arithematics.jl

@@ -1,4 +1,4 @@
-using GenericTensorNetworks, Test, OMEinsum, OMEinsumContractionOrders
+using GenericTensorNetworks, Test, OMEinsum
 using Mods, Polynomials, TropicalNumbers
 using Graphs, Random
 using GenericTensorNetworks: StaticBitVector

test/configurations.jl

@@ -1,7 +1,6 @@
 using GenericTensorNetworks, Test, Graphs
 using OMEinsum
 using TropicalNumbers: CountingTropicalF64
-using OMEinsumContractionOrders: uniformsize
 using GenericTensorNetworks: _onehotv, _x, sampler_type, set_type, best_solutions, best2_solutions, solutions, all_solutions, bestk_solutions, AllConfigs, SingleConfig, max_size, max_size_count
 
 @testset "Config types" begin

test/graph_polynomials.jl

@@ -1,4 +1,4 @@
-using GenericTensorNetworks, Test, OMEinsum, OMEinsumContractionOrders
+using GenericTensorNetworks, Test, OMEinsum
 using Mods, Polynomials, TropicalNumbers
 using Graphs, Random
 using GenericTensorNetworks: StaticBitVector, graph_polynomial

test/networks/MaximalIS.jl

@@ -39,7 +39,7 @@ end
     @test min2.coeffs == (2, 150, 7510)
 
     for bounded in [false, true]
-        println("bounded = ", bounded, ", configs max1")
+        @info("bounded = ", bounded, ", configs max1")
         @test length(solve(MaximalIS(g), ConfigsMin(; bounded=bounded))[].c) == 2
         println("bounded = ", bounded, ", configs max3")
         cmin2 = solve(MaximalIS(g), ConfigsMin(3; bounded=bounded))[]