Merge branch 'main' into bp

Author: jack-dunham

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.1"
+version = "0.3.3"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -10,9 +10,9 @@ AlgorithmsInterface = "d1e3940c-cd12-4505-8585-b0a4b322527d"
 BackendSelection = "680c2d7c-f67a-4cc9-ae9c-da132b1447a5"
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
 DataGraphs = "b5a273c3-7e6c-41f6-98bd-8d7f1525a36a"
-DerivableInterfaces = "6c5e35bf-e59e-4898-b73c-732dcc4ba65f"
 DiagonalArrays = "74fd4be6-21e2-4f6f-823a-4360d37c7a77"
 Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
+FunctionImplementations = "7c7cc465-9c6a-495f-bdd1-f42428e86d0c"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
@@ -37,13 +37,14 @@ AlgorithmsInterface = "0.1"
 BackendSelection = "0.1.6"
 Combinatorics = "1"
 DataGraphs = "0.2.7"
-DerivableInterfaces = "0.5.5"
 DiagonalArrays = "0.3.23"
 Dictionaries = "0.4.5"
+FunctionImplementations = "0.3"
 Graphs = "1.13.1"
 LinearAlgebra = "1.10"
 MacroTools = "0.5.16"
 NamedDimsArrays = "0.8, 0.9, 0.10, 0.11"
+NamedDimsArrays = "0.13"
 NamedGraphs = "0.6.9, 0.7, 0.8"
 SimpleTraits = "0.9.5"
 SplitApplyCombine = "1.2.3"

src/ITensorNetworksNext.jl

@@ -13,4 +13,4 @@ include("beliefpropagation/abstractbeliefpropagationcache.jl")
 include("beliefpropagation/beliefpropagationcache.jl")
 include("beliefpropagation/beliefpropagationproblem.jl")
 
-end
+end

src/LazyNamedDimsArrays/evaluation_order.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: dename, inds
+using NamedDimsArrays: denamed, inds
 using TermInterface: arguments, arity, operation
 
 # The time complexity of evaluating `f(args...)`.
@@ -18,16 +18,16 @@ using NamedDimsArrays: AbstractNamedDimsArray
 function time_complexity(
         ::typeof(*), t1::AbstractNamedDimsArray, t2::AbstractNamedDimsArray
     )
-    return prod(length ∘ dename, (inds(t1) ∪ inds(t2)))
+    return prod(length ∘ denamed, (inds(t1) ∪ inds(t2)))
 end
 function time_complexity(
         ::typeof(+), t1::AbstractNamedDimsArray, t2::AbstractNamedDimsArray
     )
     @assert issetequal(inds(t1), inds(t2))
-    return prod(dename, size(t1))
+    return prod(denamed, size(t1))
 end
 function time_complexity(::typeof(*), c::Number, t::AbstractNamedDimsArray)
-    return prod(dename, size(t))
+    return prod(denamed, size(t))
 end
 function time_complexity(::typeof(*), t::AbstractNamedDimsArray, c::Number)
     return time_complexity(*, c, t)

src/LazyNamedDimsArrays/lazybroadcast.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: AbstractNamedDimsArrayStyle
+using NamedDimsArrays.Broadcast: AbstractNamedDimsArrayStyle
 
 # Lazy broadcasting.
 struct LazyNamedDimsArrayStyle <: AbstractNamedDimsArrayStyle{Any} end

src/LazyNamedDimsArrays/lazyinterface.jl

@@ -1,4 +1,4 @@
-using NamedDimsArrays: dename
+using NamedDimsArrays: denamed
 using TermInterface: iscall, maketerm, operation, sorted_arguments
 using WrappedUnions: unwrap
 
@@ -23,22 +23,19 @@ opwalk(opmap, a) = walk(opmap, identity, a)
 argwalk(argmap, a) = walk(identity, argmap, a)
 
 # Generic lazy functionality.
-using DerivableInterfaces: AbstractArrayInterface, InterfaceFunction
-struct LazyInterface{N} <: AbstractArrayInterface{N} end
-LazyInterface() = LazyInterface{Any}()
-LazyInterface(::Val{N}) where {N} = LazyInterface{N}()
-LazyInterface{M}(::Val{N}) where {M, N} = LazyInterface{N}()
-const lazy_interface = LazyInterface()
+using FunctionImplementations: AbstractArrayStyle
+struct LazyStyle <: AbstractArrayStyle end
+const lazy_style = LazyStyle()
 
-const maketerm_lazy = lazy_interface(maketerm)
+const maketerm_lazy = lazy_style(maketerm)
 function maketerm_lazy(type::Type, head, args, metadata)
     if head ≡ *
         return type(maketerm(Mul, head, args, metadata))
     else
         return error("Only mul supported right now.")
     end
 end
-const getindex_lazy = lazy_interface(getindex)
+const getindex_lazy = lazy_style(getindex)
 function getindex_lazy(a::AbstractArray, I...)
     u = unwrap(a)
     if !iscall(u)
@@ -47,7 +44,7 @@ function getindex_lazy(a::AbstractArray, I...)
         return error("Indexing into expression not supported.")
     end
 end
-const arguments_lazy = lazy_interface(arguments)
+const arguments_lazy = lazy_style(arguments)
 function arguments_lazy(a)
     u = unwrap(a)
     if !iscall(u)
@@ -59,17 +56,17 @@ function arguments_lazy(a)
     end
 end
 using TermInterface: children
-const children_lazy = lazy_interface(children)
+const children_lazy = lazy_style(children)
 children_lazy(a) = arguments(a)
 using TermInterface: head
-const head_lazy = lazy_interface(head)
+const head_lazy = lazy_style(head)
 head_lazy(a) = operation(a)
-const iscall_lazy = lazy_interface(iscall)
+const iscall_lazy = lazy_style(iscall)
 iscall_lazy(a) = iscall(unwrap(a))
 using TermInterface: isexpr
-const isexpr_lazy = lazy_interface(isexpr)
+const isexpr_lazy = lazy_style(isexpr)
 isexpr_lazy(a) = iscall(a)
-const operation_lazy = lazy_interface(operation)
+const operation_lazy = lazy_style(operation)
 function operation_lazy(a)
     u = unwrap(a)
     if !iscall(u)
@@ -80,7 +77,7 @@ function operation_lazy(a)
         return error("Variant not supported.")
     end
 end
-const sorted_arguments_lazy = lazy_interface(sorted_arguments)
+const sorted_arguments_lazy = lazy_style(sorted_arguments)
 function sorted_arguments_lazy(a)
     u = unwrap(a)
     if !iscall(u)
@@ -92,12 +89,12 @@ function sorted_arguments_lazy(a)
     end
 end
 using TermInterface: sorted_children
-const sorted_children_lazy = lazy_interface(sorted_children)
+const sorted_children_lazy = lazy_style(sorted_children)
 sorted_children_lazy(a) = sorted_arguments(a)
-const ismul_lazy = lazy_interface(ismul)
+const ismul_lazy = lazy_style(ismul)
 ismul_lazy(a) = ismul(unwrap(a))
 using AbstractTrees: AbstractTrees
-const abstracttrees_children_lazy = lazy_interface(AbstractTrees.children)
+const abstracttrees_children_lazy = lazy_style(AbstractTrees.children)
 function abstracttrees_children_lazy(a)
     if !iscall(a)
         return ()
@@ -106,7 +103,7 @@ function abstracttrees_children_lazy(a)
     end
 end
 using AbstractTrees: nodevalue
-const nodevalue_lazy = lazy_interface(nodevalue)
+const nodevalue_lazy = lazy_style(nodevalue)
 function nodevalue_lazy(a)
     if !iscall(a)
         return unwrap(a)
@@ -115,11 +112,11 @@ function nodevalue_lazy(a)
     end
 end
 using Base.Broadcast: materialize
-const materialize_lazy = lazy_interface(materialize)
+const materialize_lazy = lazy_style(materialize)
 materialize_lazy(a) = argwalk(unwrap, a)
-const copy_lazy = lazy_interface(copy)
+const copy_lazy = lazy_style(copy)
 copy_lazy(a) = materialize(a)
-const equals_lazy = lazy_interface(==)
+const equals_lazy = lazy_style(==)
 function equals_lazy(a1, a2)
     u1, u2 = unwrap.((a1, a2))
     if !iscall(u1) && !iscall(u2)
@@ -130,7 +127,7 @@ function equals_lazy(a1, a2)
         return false
     end
 end
-const isequal_lazy = lazy_interface(isequal)
+const isequal_lazy = lazy_style(isequal)
 function isequal_lazy(a1, a2)
     u1, u2 = unwrap.((a1, a2))
     if !iscall(u1) && !iscall(u2)
@@ -141,13 +138,13 @@ function isequal_lazy(a1, a2)
         return false
     end
 end
-const hash_lazy = lazy_interface(hash)
+const hash_lazy = lazy_style(hash)
 function hash_lazy(a, h::UInt64)
     h = hash(Symbol(unspecify_type_parameters(typeof(a))), h)
     # Use `_hash`, which defines a custom hash for NamedDimsArray.
     return _hash(unwrap(a), h)
 end
-const map_arguments_lazy = lazy_interface(map_arguments)
+const map_arguments_lazy = lazy_style(map_arguments)
 function map_arguments_lazy(f, a)
     u = unwrap(a)
     if !iscall(u)
@@ -159,21 +156,21 @@ function map_arguments_lazy(f, a)
     end
 end
 function substitute end
-const substitute_lazy = lazy_interface(substitute)
+const substitute_lazy = lazy_style(substitute)
 function substitute_lazy(a, substitutions::AbstractDict)
     haskey(substitutions, a) && return substitutions[a]
     !iscall(a) && return a
     return map_arguments(arg -> substitute(arg, substitutions), a)
 end
 substitute_lazy(a, substitutions) = substitute(a, Dict(substitutions))
 using AbstractTrees: printnode
-const printnode_lazy = lazy_interface(printnode)
+const printnode_lazy = lazy_style(printnode)
 function printnode_lazy(io, a)
     # Use `printnode_nameddims` to avoid type piracy,
     # since it overloads on `AbstractNamedDimsArray`.
     return printnode_nameddims(io, unwrap(a))
 end
-const show_lazy = lazy_interface(show)
+const show_lazy = lazy_style(show)
 function show_lazy(io::IO, a)
     if !iscall(a)
         return show(io, unwrap(a))
@@ -187,12 +184,12 @@ function show_lazy(io::IO, mime::MIME"text/plain", a)
     !iscall(a) ? show(io, mime, unwrap(a)) : show(io, a)
     return nothing
 end
-const add_lazy = lazy_interface(+)
+const add_lazy = lazy_style(+)
 add_lazy(a1, a2) = error("Not implemented.")
-const sub_lazy = lazy_interface(-)
+const sub_lazy = lazy_style(-)
 sub_lazy(a) = error("Not implemented.")
 sub_lazy(a1, a2) = error("Not implemented.")
-const mul_lazy = lazy_interface(*)
+const mul_lazy = lazy_style(*)
 function mul_lazy(a)
     u = unwrap(a)
     if !iscall(u)
@@ -216,7 +213,7 @@ mul_lazy(a1::Number, a2::Number) = a1 * a2
 div_lazy(a1, a2::Number) = error("Not implemented.")
 
 # NamedDimsArrays.jl interface.
-const inds_lazy = lazy_interface(inds)
+const inds_lazy = lazy_style(inds)
 function inds_lazy(a)
     u = unwrap(a)
     if !iscall(u)
@@ -227,11 +224,11 @@ function inds_lazy(a)
         return error("Variant not supported.")
     end
 end
-const dename_lazy = lazy_interface(dename)
-function dename_lazy(a)
+const denamed_lazy = lazy_style(denamed)
+function denamed_lazy(a)
     u = unwrap(a)
     if !iscall(u)
-        return dename(u)
+        return denamed(u)
     else
         return error("Variant not supported.")
     end

src/LazyNamedDimsArrays/lazynameddimsarray.jl

@@ -24,7 +24,7 @@ lazy(a::AbstractNamedDimsArray) = LazyNamedDimsArray(a)
 lazy(a::Mul{<:LazyNamedDimsArray}) = LazyNamedDimsArray(a)
 
 NamedDimsArrays.inds(a::LazyNamedDimsArray) = inds_lazy(a)
-NamedDimsArrays.dename(a::LazyNamedDimsArray) = dename_lazy(a)
+NamedDimsArrays.denamed(a::LazyNamedDimsArray) = denamed_lazy(a)
 
 # Broadcasting
 function Base.BroadcastStyle(::Type{<:LazyNamedDimsArray})

src/LazyNamedDimsArrays/nameddimsarraysextensions.jl

@@ -1,11 +1,11 @@
-using NamedDimsArrays: NamedDimsArray, dename, inds
+using NamedDimsArrays: NamedDimsArray, denamed, inds
 # Defined to avoid type piracy.
 # TODO: Define a proper hash function
 # in NamedDimsArrays.jl, maybe one that is
 # independent of the order of dimensions.
 function _hash(a::NamedDimsArray, h::UInt64)
     h = hash(:NamedDimsArray, h)
-    h = hash(dename(a), h)
+    h = hash(denamed(a), h)
     for i in inds(a)
         h = hash(i, h)
     end

src/LazyNamedDimsArrays/symbolicarray.jl

@@ -28,8 +28,8 @@ end
 function Base.setindex!(a::SymbolicArray{<:Any, N}, value, I::Vararg{Int, N}) where {N}
     return error("Indexing into SymbolicArray not supported.")
 end
-using DerivableInterfaces: DerivableInterfaces
-DerivableInterfaces.permuteddims(a::SymbolicArray, p) = permutedims(a, p)
+using FunctionImplementations: FunctionImplementations
+FunctionImplementations.permuteddims(a::SymbolicArray, p) = permutedims(a, p)
 function Base.permutedims(a::SymbolicArray, p)
     @assert ndims(a) == length(p) && isperm(p)
     return SymbolicArray(symname(a), ntuple(i -> axes(a)[p[i]], ndims(a)))

src/LazyNamedDimsArrays/symbolicnameddimsarray.jl

@@ -1,25 +1,25 @@
-using NamedDimsArrays: NamedDimsArray, dename, inds, nameddims
+using NamedDimsArrays: NamedDimsArray, denamed, inds, nameddims
 
 const SymbolicNamedDimsArray{T, N, Parent <: SymbolicArray{T, N}, DimNames} =
     NamedDimsArray{T, N, Parent, DimNames}
 function symnameddims(name, dims)
-    return lazy(nameddims(SymbolicArray(name, dename.(dims)), dims))
+    return lazy(nameddims(SymbolicArray(name, denamed.(dims)), dims))
 end
 function symnameddims(name, ndarray::AbstractNamedDimsArray)
     return symnameddims(name, Tuple(inds(ndarray)))
 end
 symnameddims(name) = symnameddims(name, ())
 using AbstractTrees: AbstractTrees
 function AbstractTrees.printnode(io::IO, a::SymbolicNamedDimsArray)
-    print(io, symname(dename(a)))
+    print(io, symname(denamed(a)))
     if ndims(a) > 0
         print(io, "[", join(dimnames(a), ","), "]")
     end
     return nothing
 end
 printnode_nameddims(io::IO, a::SymbolicNamedDimsArray) = AbstractTrees.printnode(io, a)
 function Base.:(==)(a::SymbolicNamedDimsArray, b::SymbolicNamedDimsArray)
-    return issetequal(inds(a), inds(b)) && dename(a) == dename(b)
+    return issetequal(inds(a), inds(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, dename, inds, operator, randname
+using NamedDimsArrays: apply, denamed, inds, operator, randname
 using NamedGraphs.GraphsExtensions: vertextype
 
 function sqrt_ising_bond(β; J = one(β), h = zero(β), deg1::Integer, deg2::Integer)
@@ -33,7 +33,7 @@ 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], dename.(inds(tn[v])))
+        a = DiagonalArray(elt[1, -1], denamed.(inds(tn[v])))
         tn[v] = a[inds(tn[v])...]
     end
     for e in edges(tn)