Upgrade to NamedDimsArrays.jl v0.14, ITensorBase.jl v0.5

Project.toml

@@ -1,7 +1,7 @@
 name = "ITensorNetworksNext"
 uuid = "302f2e75-49f0-4526-aef7-d8ba550cb06c"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
-version = "0.3.6"
+version = "0.3.7"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -37,13 +37,13 @@ AlgorithmsInterface = "0.1"
 BackendSelection = "0.1.6"
 Combinatorics = "1"
 DataGraphs = "0.2.7"
-DiagonalArrays = "0.3.23"
+DiagonalArrays = "0.3.31"
 Dictionaries = "0.4.5"
 FunctionImplementations = "0.4"
 Graphs = "1.13.1"
 LinearAlgebra = "1.10"
 MacroTools = "0.5.16"
-NamedDimsArrays = "0.13"
+NamedDimsArrays = "0.14.2"
 NamedGraphs = "0.6.9, 0.7, 0.8"
 SimpleTraits = "0.9.5"
 SplitApplyCombine = "1.2.3"

src/LazyNamedDimsArrays/evaluation_order.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: denamed, inds
+using NamedDimsArrays: denamed, dimnames, inds
 using TermInterface: arguments, arity, operation
 
 # The time complexity of evaluating `f(args...)`.
@@ -23,7 +23,7 @@ end
 function time_complexity(
         ::typeof(+), t1::AbstractNamedDimsArray, t2::AbstractNamedDimsArray
     )
-    @assert issetequal(inds(t1), inds(t2))
+    @assert issetequal(dimnames(t1), dimnames(t2))
     return prod(denamed, size(t1))
 end
 function time_complexity(::typeof(*), c::Number, t::AbstractNamedDimsArray)
@@ -100,7 +100,7 @@ function optimize_contraction_order(alg::Algorithm"eager", a)
         # Penalize outer product contractions.
         # TODO: Still order the outer products by time complexity,
         # say by checking if there are only outer products left.
-        isdisjoint(inds(a1), inds(a2)) && return typemax(Int)
+        isdisjoint(dimnames(a1), dimnames(a2)) && return typemax(Int)
         return time_complexity(*, a1, a2)
     end
     contracted_arguments = [filter(∉((a1, a2)), arguments(a)); [a1 * a2]]

src/LazyNamedDimsArrays/lazyinterface.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: denamed
+using NamedDimsArrays: denamed, dimnames, inds
 using TermInterface: iscall, maketerm, operation, sorted_arguments
 using WrappedUnions: unwrap
 
@@ -213,6 +213,17 @@ mul_lazy(a1::Number, a2::Number) = a1 * a2
 div_lazy(a1, a2::Number) = error("Not implemented.")
 
 # NamedDimsArrays.jl interface.
+const dimnames_lazy = lazy_style(dimnames)
+function dimnames_lazy(a)
+    u = unwrap(a)
+    if !iscall(u)
+        return dimnames(u)
+    elseif ismul(u)
+        return mapreduce(dimnames, symdiff, arguments(u))
+    else
+        return error("Variant not supported.")
+    end
+end
 const inds_lazy = lazy_style(inds)
 function inds_lazy(a)
     u = unwrap(a)

src/LazyNamedDimsArrays/lazynameddimsarray.jl

@@ -23,6 +23,7 @@ lazy(a::LazyNamedDimsArray) = a
 lazy(a::AbstractNamedDimsArray) = LazyNamedDimsArray(a)
 lazy(a::Mul{<:LazyNamedDimsArray}) = LazyNamedDimsArray(a)
 
+NamedDimsArrays.dimnames(a::LazyNamedDimsArray) = dimnames_lazy(a)
 NamedDimsArrays.inds(a::LazyNamedDimsArray) = inds_lazy(a)
 NamedDimsArrays.denamed(a::LazyNamedDimsArray) = denamed_lazy(a)
 

src/LazyNamedDimsArrays/symbolicnameddimsarray.jl

@@ -1,9 +1,9 @@
-using NamedDimsArrays: NamedDimsArray, denamed, inds, nameddims
+using NamedDimsArrays: NamedDimsArray, denamed, dimnames, name, nameddims
 
 const SymbolicNamedDimsArray{T, N, Parent <: SymbolicArray{T, N}, DimNames} =
     NamedDimsArray{T, N, Parent, DimNames}
-function symnameddims(name, dims)
-    return lazy(nameddims(SymbolicArray(name, denamed.(dims)), dims))
+function symnameddims(symname, dims)
+    return lazy(nameddims(SymbolicArray(symname, denamed.(dims)), name.(dims)))
 end
 symnameddims(name) = symnameddims(name, ())
 using AbstractTrees: AbstractTrees
@@ -16,7 +16,7 @@ function AbstractTrees.printnode(io::IO, a::SymbolicNamedDimsArray)
 end
 printnode_nameddims(io::IO, a::SymbolicNamedDimsArray) = AbstractTrees.printnode(io, a)
 function Base.:(==)(a::SymbolicNamedDimsArray, b::SymbolicNamedDimsArray)
-    return issetequal(inds(a), inds(b)) && denamed(a) == denamed(b)
+    return issetequal(dimnames(a), dimnames(b)) && denamed(a) == denamed(b)
 end
 Base.:*(a::SymbolicNamedDimsArray, b::SymbolicNamedDimsArray) = lazy(a) * lazy(b)
 Base.:*(a::SymbolicNamedDimsArray, b::LazyNamedDimsArray) = lazy(a) * b

src/TensorNetworkGenerators/ising_network.jl

@@ -2,7 +2,7 @@ using DiagonalArrays: DiagonalArray
 using Graphs: degree, dst, edges, src
 using ..ITensorNetworksNext: @preserve_graph
 using LinearAlgebra: Diagonal, eigen
-using NamedDimsArrays: apply, denamed, inds, operator, randname
+using NamedDimsArrays: apply, denamed, name, operator, randname
 using NamedGraphs.GraphsExtensions: vertextype
 
 function sqrt_ising_bond(β; J = one(β), h = zero(β), deg1::Integer, deg2::Integer)
@@ -33,16 +33,16 @@ function ising_network(
     f̃(e) = get(() -> l̃[reverse(e)], l̃, e)
     tn = delta_network(f̃, elt, g)
     for v in sz_vertices
-        a = DiagonalArray(elt[1, -1], denamed.(inds(tn[v])))
-        tn[v] = a[inds(tn[v])...]
+        a = DiagonalArray(elt[1, -1], denamed.(axes(tn[v])))
+        tn[v] = a[axes(tn[v])...]
     end
     for e in edges(tn)
         v1 = src(e)
         v2 = dst(e)
         deg1 = degree(tn, v1)
         deg2 = degree(tn, v2)
         m = sqrt_ising_bond(β; J, h, deg1, deg2)
-        t = operator(m, (f̃(e),), (f(e),))
+        t = operator(m, (name(f̃(e)),), (name(f(e)),))
         @preserve_graph tn[v1] = apply(t, tn[v1])
         @preserve_graph tn[v2] = apply(t, tn[v2])
     end

src/contract_network.jl

@@ -38,12 +38,12 @@ function get_order(alg::Algorithm"exact", tn)
     end
     # Contraction order may or may not have indices attached, canonicalize the format
     # by attaching indices.
-    subs = Dict(symnameddims(i) => symnameddims(i, Tuple(inds(tn[i]))) for i in keys(tn))
+    subs = Dict(symnameddims(i) => symnameddims(i, Tuple(axes(tn[i]))) for i in keys(tn))
     return substitute(order, subs)
 end
 function contract_network(alg::Algorithm"exact", tn)
     order = get_order(alg, tn)
-    syms_to_ts = Dict(symnameddims(i, Tuple(inds(tn[i]))) => lazy(tn[i]) for i in keys(tn))
+    syms_to_ts = Dict(symnameddims(i, Tuple(axes(tn[i]))) => lazy(tn[i]) for i in keys(tn))
     tn_expression = substitute(order, syms_to_ts)
     return materialize(tn_expression)
 end
@@ -57,11 +57,11 @@ end
 # Convert the tensor network to a flat symbolic multiplication expression.
 function contraction_order(alg::Algorithm"flat", tn)
     # Same as: `reduce((a, b) -> *(a, b; flatten = true), syms)`.
-    syms = vec([symnameddims(i, Tuple(inds(tn[i]))) for i in keys(tn)])
+    syms = vec([symnameddims(i, Tuple(axes(tn[i]))) for i in keys(tn)])
     return lazy(Mul(syms))
 end
 function contraction_order(alg::Algorithm"left_associative", tn)
-    return prod(i -> symnameddims(i, Tuple(inds(tn[i]))), keys(tn))
+    return prod(i -> symnameddims(i, Tuple(axes(tn[i]))), keys(tn))
 end
 function contraction_order(alg::Algorithm, tn)
     s = contraction_order(Algorithm"flat"(), tn)

test/Project.toml

@@ -27,9 +27,9 @@ Aqua = "0.8.14"
 DiagonalArrays = "0.3.23"
 Dictionaries = "0.4.5"
 Graphs = "1.13.1"
-ITensorBase = "0.3, 0.4"
+ITensorBase = "0.5"
 ITensorNetworksNext = "0.3"
-NamedDimsArrays = "0.13"
+NamedDimsArrays = "0.14"
 NamedGraphs = "0.6.8, 0.7, 0.8"
 QuadGK = "2.11.2"
 SafeTestsets = "0.1"