Loosen linkdim(::AbstractITensorNetwork, ::AbstractEdge) signature

The previous signature
`linkdim(tn::AbstractITensorNetwork{V}, edge::AbstractEdge{V}) where V`
required the network's vertex-type parameter and the edge's vertex-type
parameter to match exactly. For graphs with abstract V (e.g. the
`NamedGraph{Tuple}` produced by `named_binary_tree`, where vertices are
tuples of varying arity), downstream operations can produce edges whose
V parameter is a strict subtype — for example, `subgraph(g, vs)` where
`vs` came from a Dict's keys and concretized to
`Tuple{Int64, Vararg{Int64}}`. In that situation dispatch failed with
`MethodError` even though `linkinds` itself accepts the edge fine.

Drop the `{V}` constraint so `linkdim` accepts any `AbstractEdge`
alongside any `AbstractITensorNetwork`. Behavior is unchanged for cases
that previously dispatched; previously-failing cases now go through.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mtfishman

src/abstractitensornetwork.jl

@@ -556,7 +556,7 @@ function linkdim(tn::AbstractITensorNetwork, edge::Pair)
     return linkdim(tn, edgetype(tn)(edge))
 end
 
-function linkdim(tn::AbstractITensorNetwork{V}, edge::AbstractEdge{V}) where {V}
+function linkdim(tn::AbstractITensorNetwork, edge::AbstractEdge)
     ls = linkinds(tn, edge)
     return prod([isnothing(l) ? 1 : dim(l) for l in ls])
 end

test/test_itensornetwork.jl

@@ -9,8 +9,8 @@ using ITensors.NDTensors: NDTensors, dim
 using ITensors: ITensors, ITensor, Index, Op, commonind, commoninds, contract, dag, hasinds,
     inds, inner, itensor, onehot, order, prime, random_itensor, scalartype, sim
 using NDTensors: NDTensors, dim
-using NamedGraphs.GraphsExtensions: disjoint_union, incident_edges
-using NamedGraphs.NamedGraphGenerators: named_comb_tree, named_grid
+using NamedGraphs.GraphsExtensions: disjoint_union, incident_edges, subgraph
+using NamedGraphs.NamedGraphGenerators: named_binary_tree, named_comb_tree, named_grid
 using NamedGraphs: NamedEdge
 using Random: randn!
 using StableRNGs: StableRNG
@@ -250,4 +250,33 @@ const elts = (Float32, Float64, Complex{Float32}, Complex{Float64})
         tn = random_tensornetwork(rng, is; link_space = 3)
         @test_broken swapprime(tn, 0, 2)
     end
+
+    # `named_binary_tree` has vertices of varying tuple arity (`(1,)`, `(1,1)`,
+    # …), so its V parameter is the abstract `Tuple`. Downstream graph
+    # operations can produce edges with a more concrete vertex-type parameter —
+    # for example `subgraph(g, collect(keys(dict)))` where the dict's key type
+    # has concretized to `Tuple{Int64, Vararg{Int64}}`. Previously
+    # `linkdim(::AbstractITensorNetwork{V}, ::AbstractEdge{V}) where V` required
+    # both `V`s to match exactly and failed in that case; the loosened signature
+    # accepts any compatible edge.
+    @testset "linkdim accepts an AbstractEdge whose vertex type is a subtype" begin
+        g = named_binary_tree(3)
+        is = siteinds("S=1/2", g)
+        rng = StableRNG(1234)
+        tn = random_tensornetwork(rng, is; link_space = 3)
+        @test tn isa ITensorNetwork{Tuple}
+
+        # The matching-V case still works.
+        e = first(edges(g))
+        @test e isa NamedEdge{Tuple}
+        @test ITensorNetworks.linkdim(tn, e) == 3
+
+        # The concrete-V edge from a typed-key Dict-driven subgraph, which is
+        # the path that was previously broken.
+        site_inds = Dict(v => is[v] for v in vertices(g))
+        g_sub = subgraph(g, collect(keys(site_inds)))
+        e_concrete = first(edges(g_sub))
+        @test e_concrete isa NamedEdge{Tuple{Int, Vararg{Int}}}
+        @test ITensorNetworks.linkdim(tn, e_concrete) == 3
+    end
 end