docs: rebuild random_state helper using basic Dict-of-ITensor constructor

Switch the `@setup` / `@example` blocks in `docs/src/computing_properties.md`
and `docs/src/solvers.md` from the function-callback `ITensorNetwork(s; link_space, kwargs...) do v ... end`
form to an explicit construction:

  1. build a `Dict{Edge, Index}` of link indices over `edges(g)` (mirrored
     under `reverse(e)`),
  2. build an `ITensor` for each vertex from the site index plus the link
     indices on that vertex's incident edges,
  3. wrap with the basic `ITensorNetwork(::Dict{V, ITensor})` constructor.

Mirrors the construction pattern used in the ITensorNetworksNext.jl tests
and avoids leaning on the `do v ... end` higher-level constructor that we
intend to phase out.

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

Author: mtfishman

docs/src/computing_properties.md

@@ -1,23 +1,29 @@
 # Computing Properties
 
 ```@setup main
-using Graphs: vertices
+using Graphs: edges, vertices
 using ITensorNetworks: ITensorNetwork, expect, inner, loginner, normalize, siteinds, ttn
-using ITensors: itensor
-using ITensors.NDTensors: dim
+using ITensors: Index, random_itensor
 using LinearAlgebra: norm
+using NamedGraphs.GraphsExtensions: incident_edges
 using NamedGraphs.NamedGraphGenerators: named_grid
 
-random_state(s) = ITensorNetwork(s; link_space = 2) do v
-    return inds -> itensor(randn(Float64, dim.(inds)...), inds)
+function random_state(g, s; link_space = 2)
+    l = Dict(e => Index(link_space, "Link") for e in edges(g))
+    l = merge(l, Dict(reverse(e) => l[e] for e in edges(g)))
+    ts = Dict(
+        v => random_itensor(only(s[v]), (l[e] for e in incident_edges(g, v))...)
+            for v in vertices(g)
+    )
+    return ITensorNetwork(ts)
 end
 
 g = named_grid((4,))
 s = siteinds("S=1/2", g)
-phi = normalize(ttn(random_state(s)))
-psi = normalize(ttn(random_state(s)))
-x = normalize(ttn(random_state(s)))
-y = normalize(ttn(random_state(s)))
+phi = normalize(ttn(random_state(g, s)))
+psi = normalize(ttn(random_state(g, s)))
+x = normalize(ttn(random_state(g, s)))
+y = normalize(ttn(random_state(g, s)))
 v = first(vertices(psi))
 ```
 

docs/src/solvers.md

@@ -16,13 +16,20 @@ variational sweep algorithm.
 [`dmrg`](@ref ITensorNetworks.dmrg) is an alias for `eigsolve`.
 
 ```@example main
+using Graphs: vertices
 using ITensorNetworks: ITensorNetwork, dmrg, dst, edges, normalize, siteinds, src, ttn
-using ITensors: OpSum, itensor
-using ITensors.NDTensors: dim
+using ITensors: Index, OpSum, random_itensor
+using NamedGraphs.GraphsExtensions: incident_edges
 using NamedGraphs.NamedGraphGenerators: named_comb_tree
 
-random_state(s) = ITensorNetwork(s; link_space = 2) do v
-    return inds -> itensor(randn(Float64, dim.(inds)...), inds)
+function random_state(g, s; link_space = 2)
+    l = Dict(e => Index(link_space, "Link") for e in edges(g))
+    l = merge(l, Dict(reverse(e) => l[e] for e in edges(g)))
+    ts = Dict(
+        v => random_itensor(only(s[v]), (l[e] for e in incident_edges(g, v))...)
+            for v in vertices(g)
+    )
+    return ITensorNetwork(ts)
 end
 
 # Build a Heisenberg Hamiltonian on a comb tree
@@ -38,7 +45,7 @@ H = let h = OpSum()
 end
 
 # Random initial state (normalise first!)
-psi0 = normalize(ttn(random_state(s)))
+psi0 = normalize(ttn(random_state(g, s)))
 
 # Run DMRG
 energy, psi = dmrg(H, psi0;