Cut down ITN and TTN constructor surface

- Drop ITensorNetwork{V}() empty-arg ctor; inline the three-field call
  at the single seed site inside ITensorNetwork{V}(tensors). External
  callers that want an empty network can pass an empty tensor
  collection (Dict{V, ITensor}() etc.).
- Drop the TreeTensorNetwork(::ITensorNetwork; ortho_region=...) and
  TreeTensorNetwork{V}(::ITensorNetwork) overloads. All construction
  now routes through TreeTensorNetwork(tensors; ortho_region=nothing),
  which builds an ITensorNetwork first and then performs the is_tree
  check.
- Define Base.keytype on AbstractITensorNetwork so an AbstractITN can
  be passed as a tensor collection to ITensorNetwork(tensors).

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

Author: mtfishman

src/abstractitensornetwork.jl

@@ -45,6 +45,8 @@ Base.copy(tn::AbstractITensorNetwork) = not_implemented()
 # whether `vertex_data` is a `Dict`, `Dictionary`, or anything else with
 # different default-iteration semantics.
 Base.keys(tn::AbstractITensorNetwork) = vertices(tn)
+Base.keytype(::Type{<:AbstractITensorNetwork{V}}) where {V} = V
+Base.keytype(tn::AbstractITensorNetwork) = keytype(typeof(tn))
 Base.values(tn::AbstractITensorNetwork) = (tn[v] for v in vertices(tn))
 Base.iterate(tn::AbstractITensorNetwork, args...) = iterate(values(tn), args...)
 

src/itensornetwork.jl

@@ -69,22 +69,15 @@ end
 # Constructors
 #
 
-# Empty network with no vertices, used as the starting point for the
-# tensor-collection constructor below.
-function ITensorNetwork{V}() where {V}
-    return ITensorNetwork{V}(
-        NamedGraph{V}(), Dictionary{V, ITensor}(), Dict{Index, Set{V}}()
-    )
-end
-
 # Construct by feeding `tensors` through `set_vertex_data!` one vertex
 # at a time — this centralizes the reverse-map registration, edge
 # inference, and hypergraph check in a single place (the `setindex!`
 # code path). Walking `keys(tensors)` in order makes the resulting
 # `neighbors(g, v)` / `edges(g)` iteration order deterministic in the
-# input order.
+# input order. An empty `tensors` (`Dict{V, ITensor}()`, etc.) yields
+# an empty network — there is no separate empty-arg constructor.
 function ITensorNetwork{V}(tensors) where {V}
-    tn = ITensorNetwork{V}()
+    tn = ITensorNetwork{V}(NamedGraph{V}(), Dictionary{V, ITensor}(), Dict{Index, Set{V}}())
     for v in keys(tensors)
         set_vertex_data!(tn, tensors[v], v)
     end

src/treetensornetworks/treetensornetwork.jl

@@ -27,15 +27,17 @@ struct TreeTensorNetwork{V} <: AbstractTreeTensorNetwork{V}
 end
 
 """
-    TreeTensorNetwork(tn::ITensorNetwork; ortho_region=vertices(tn)) -> TreeTensorNetwork
+    TreeTensorNetwork(tensors; ortho_region=nothing) -> TreeTensorNetwork
 
-Construct a `TreeTensorNetwork` from an `ITensorNetwork` with tree graph structure.
+Construct a `TreeTensorNetwork` from any collection of tensors accepted by
+`ITensorNetwork` (e.g. a `Dict`, `Dictionary`, a `Vector{ITensor}`, or another
+`AbstractITensorNetwork`). Edges are inferred from shared `Index`es; the
+underlying graph must be a tree.
 
-The `ortho_region` keyword specifies which vertices currently form the orthogonality center.
-By default all vertices are included, meaning no particular gauge is assumed. To enforce an
-actual orthogonal gauge, call [`orthogonalize`](@ref) afterward.
-
-Throws an error if the underlying graph of `tn` is not a tree.
+`ortho_region` specifies which vertices currently form the orthogonality
+center. The default `nothing` includes all vertices, meaning no particular
+gauge is assumed. To enforce an actual orthogonal gauge, call
+[`orthogonalize`](@ref) afterward.
 
 # Example
 
@@ -54,23 +56,16 @@ julia> ttn = TreeTensorNetwork(itn; ortho_region = [first(vertices(itn))]);
 
 See also: [`ITensorNetwork`](@ref), [`orthogonalize`](@ref).
 """
-function TreeTensorNetwork(tn::ITensorNetwork{V}; ortho_region = vertices(tn)) where {V}
-    @assert is_tree(tn)
+function TreeTensorNetwork(tensors; ortho_region = nothing)
+    itn = ITensorNetwork(tensors)
+    @assert is_tree(itn)
+    V = vertextype(itn)
+    region = isnothing(ortho_region) ? vertices(itn) : ortho_region
     return TreeTensorNetwork{V}(
-        tn.graph, tn.vertex_data, tn.ind_to_vertices, Indices{V}(ortho_region)
+        itn.graph, itn.vertex_data, itn.ind_to_vertices, Indices{V}(region)
     )
 end
 
-function TreeTensorNetwork{V}(tn::ITensorNetwork) where {V}
-    return TreeTensorNetwork(ITensorNetwork{V}(tn))
-end
-
-# Build a `TreeTensorNetwork` directly from a tensor collection (anything
-# accepted by `ITensorNetwork`), saving the caller a wrapping step.
-function TreeTensorNetwork(tensors; kwargs...)
-    return TreeTensorNetwork(ITensorNetwork(tensors); kwargs...)
-end
-
 const TTN = TreeTensorNetwork
 
 # Field access