Updates

Author: JoeyT1994

Project.toml

@@ -21,7 +21,6 @@ TypeParameterAccessors = "7e5a90cf-f82e-492e-a09b-e3e26432c138"
 WrappedUnions = "325db55a-9c6c-5b90-b1a2-ec87e7a38c44"
 
 [weakdeps]
-ITensorBase = "4795dd04-0d67-49bb-8f44-b89c448a1dc7"
 TensorOperations = "6aa20fa7-93e2-5fca-9bc0-fbd0db3c71a2"
 
 [extensions]

ext/ITensorNetworksNextTensorOperationsExt/ITensorNetworksNextTensorOperationsExt.jl

@@ -2,16 +2,15 @@ module ITensorNetworksNextTensorOperationsExt
 
 using BackendSelection: @Algorithm_str, Algorithm
 using NamedDimsArrays: inds
-using ITensorNetworksNext: ITensorNetworksNext
-using ITensorNetworksNext.LazyNamedDimsArrays: nested_array_to_lazy_multiply
+using ITensorNetworksNext: ITensorNetworksNext, contraction_sequence_to_expr
 using TensorOperations: TensorOperations, optimaltree
 
 function ITensorNetworksNext.contraction_sequence(::Algorithm"optimal", tn::Vector{<:AbstractArray})
     network = collect.(inds.(tn))
     #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)
-    return nested_array_to_lazy_multiply(seq)
+    return contraction_sequence_to_expr(seq)
 end
 
 end

src/contractnetwork.jl

@@ -1,18 +1,24 @@
 using BackendSelection: @Algorithm_str, Algorithm
-using ITensorNetworksNext.LazyNamedDimsArrays: nested_array_to_lazy_multiply, substitute_lazy, materialize, lazy,
+using ITensorNetworksNext.LazyNamedDimsArrays: substitute, materialize, lazy,
     symnameddims
 
-default_contract_alg = nothing
-
 #Algorithmic defaults
 default_sequence(::Algorithm"exact") = "leftassociative"
 function set_default_kwargs(alg::Algorithm"exact")
     sequence = get(alg, :sequence, default_sequence(alg))
     return Algorithm("exact"; sequence)
 end
 
+function contraction_sequence_to_expr(seq)
+    if seq isa AbstractVector
+        return prod(contraction_sequence_to_expr, seq)
+    else
+        return symnameddims(seq)
+    end
+end
+
 function contraction_sequence(::Algorithm"leftassociative", tn::Vector{<:AbstractArray})
-    return nested_array_to_lazy_multiply(collect.(1:length(tn)))
+    return contraction_sequence_to_expr(collect.(1:length(tn)))
 end
 
 function contraction_sequence(tn::Vector{<:AbstractArray}; alg = default_sequence_alg)
@@ -21,15 +27,14 @@ end
 
 function contractnetwork(alg::Algorithm"exact", tn::Vector{<:AbstractArray})
     contract_sequence = isa(alg.sequence, String) ? contraction_sequence(tn; alg = alg.sequence) : sequence
-    contract_sequence = substitute_lazy(contract_sequence, Dict(symnameddims(i) => lazy(tn[i]) for i in 1:length(tn)))
+    contract_sequence = substitute(contract_sequence, Dict(symnameddims(i) => lazy(tn[i]) for i in 1:length(tn)))
     return materialize(contract_sequence)
 end
 
 function contractnetwork(alg::Algorithm"exact", tn::AbstractTensorNetwork)
     return contractnetwork(alg, [tn[v] for v in vertices(tn)])
 end
 
-function contractnetwork(tn::Union{AbstractTensorNetwork, Vector{<:AbstractArray}}; alg = default_contract_alg, kwargs...)
-    alg == nothing && error("Must specify an algorithm to contract the network with")
+function contractnetwork(tn; alg, kwargs...)
     return contractnetwork(set_default_kwargs(Algorithm(alg; kwargs...)), tn)
 end

src/lazynameddimsarrays.jl

@@ -417,12 +417,4 @@ Base.:*(a::SymbolicNamedDimsArray, b::SymbolicNamedDimsArray) = lazy(a) * lazy(b
 Base.:*(a::SymbolicNamedDimsArray, b::LazyNamedDimsArray) = lazy(a) * b
 Base.:*(a::LazyNamedDimsArray, b::SymbolicNamedDimsArray) = a * lazy(b)
 
-function contraction_sequence_to_expr(seq)
-    if seq isa AbstractVector
-        return prod(contraction_sequence_to_expr, seq)
-    else
-        return symnameddims(seq)
-    end
-end
-
 end