Fix tests

Author: mtfishman

ext/ITensorNetworksNextTensorOperationsExt/ITensorNetworksNextTensorOperationsExt.jl

@@ -2,22 +2,25 @@ module ITensorNetworksNextTensorOperationsExt
 
 using BackendSelection: @Algorithm_str, Algorithm
 using ITensorNetworksNext: ITensorNetworksNext, contraction_order
+using ITensorNetworksNext.LazyNamedDimsArrays: symnameddims, substitute
 using NamedDimsArrays: inds
 using TensorOperations: TensorOperations, optimaltree
 
-function contraction_order_to_expr(seq)
-    return seq isa AbstractVector ? prod(contraction_order_to_expr, seq) : symnameddims(seq)
+function contraction_order_to_expr(ord)
+    return ord isa AbstractVector ? prod(contraction_order_to_expr, ord) : symnameddims(ord)
 end
 
 function ITensorNetworksNext.contraction_order(alg::Algorithm"optimal", tn)
-    ts = [tn[i] for i in eachindex(tn)]
+    ts = [tn[i] for i in keys(tn)]
     network = collect.(inds.(ts))
     # Converting dims to Float64 to minimize overflow issues
     inds_to_dims = Dict(i => Float64(length(i)) for i in unique(reduce(vcat, network)))
-    seq, _ = optimaltree(network, inds_to_dims)
+    order, _ = optimaltree(network, inds_to_dims)
     # TODO: Map the integer indices back to the original tensor network vertices.
-    expr = contraction_order_to_expr(seq)
-    subs = Dict(symnameddims(i) => symnameddims(eachindex(tn)[i]) for i in eachindex(ts))
+    expr = contraction_order_to_expr(order)
+    verts = collect(keys(tn))
+    sym(i) = symnameddims(verts[i], Tuple(inds(tn[verts[i]])))
+    subs = Dict(symnameddims(i) => sym(i) for i in eachindex(verts))
     return substitute(expr, subs)
 end
 

test/test_contract_network.jl

@@ -14,10 +14,11 @@ using Test: @test, @testset
         C = ITensor([5.0, 1.0], j)
         D = ITensor([-2.0, 3.0, 4.0, 5.0, 1.0], k)
 
-        ABCD_1 = contract_network([A, B, C, D]; alg = "exact", order_alg = "leftassociative")
-        ABCD_2 = contract_network([A, B, C, D]; alg = "exact", order_alg = "optimal")
+        ABCD_1 = contract_network([A, B, C, D]; order_alg = "left_associative")
+        ABCD_2 = contract_network([A, B, C, D]; order_alg = "eager")
+        ABCD_3 = contract_network([A, B, C, D]; order_alg = "optimal")
 
-        @test ABCD_1 == ABCD_2
+        @test ABCD_1 == ABCD_2 == ABCD_3
     end
 
     @testset "Contract One Dimensional Network" begin
@@ -30,9 +31,11 @@ using Test: @test, @testset
             return randn(Tuple(is))
         end
 
-        z1 = contract_network(tn; alg = "exact", sequence_alg = "optimal")[]
-        z2 = contract_network(tn; alg = "exact", sequence_alg = "leftassociative")[]
+        z1 = contract_network(tn; order_alg = "left_associative")[]
+        z2 = contract_network(tn; order_alg = "eager")[]
+        z3 = contract_network(tn; order_alg = "optimal")[]
 
         @test abs(z1 - z2) / abs(z1) <= 1.0e3 * eps(Float64)
+        @test abs(z1 - z3) / abs(z1) <= 1.0e3 * eps(Float64)
     end
 end