various fixes

lkdvos · lkdvos · commit 2bf400bf71a8 · 2025-11-09T20:21:30.000-05:00
diff --git a/src/states/abstractmps.jl b/src/states/abstractmps.jl
@@ -223,6 +223,13 @@ This might be useful to construct "charged" MPS, or to work with [`WindowMPS`](@
 struct FiniteMPSManifold{S <: ElementarySpace, S′ <: TensorSpace{S}} <: AbstractMPSManifold{S}
     pspaces::Vector{S′}
     vspaces::Vector{S}
+
+    # disable default constructor
+    function FiniteMPSManifold{S, S′}(
+            pspaces::Vector{S′}, vspaces::Vector{S}
+        ) where {S <: ElementarySpace, S′ <: TensorSpace{S}}
+        return new{S, S′}(pspaces, vspaces)
+    end
 end
 
 function FiniteMPSManifold(
@@ -245,7 +252,7 @@ end
 function FiniteMPSManifold(
         physicalspaces::AbstractVector{S′}, max_virtualspace::S; kwargs...
     ) where {S <: ElementarySpace, S′ <: TensorSpace{S}}
-    return FiniteMPSManifold(physicalspaces, fill(max_virtualspace, length(physicalspaces) - 1))
+    return FiniteMPSManifold(physicalspaces, fill(max_virtualspace, length(physicalspaces) - 1); kwargs...)
 end
 function FiniteMPSManifold(mps_tensors::AbstractVector{A}) where {A <: GenericMPSTensor}
     numin(A) == 1 || throw(ArgumentError("Not a valid MPS tensor space"))
@@ -302,9 +309,9 @@ function InfiniteMPSManifold(
     # ensure all spaces are full rank -- use vspaces as maximum
     return makefullrank!(manifold)
 end
-function InfiniteMPSManifold(mps_tensors::PeriodicVector{A}) where {A <: GenericMPSTensor}
-    pspaces = map(physicalspace, mps_tensors)
-    vspaces = map(left_virtualspace, mps_tensors)
+function InfiniteMPSManifold(mps_tensors::AbstractVector{A}) where {A <: GenericMPSTensor}
+    pspaces = PeriodicVector(map(physicalspace, mps_tensors))
+    vspaces = PeriodicVector(map(left_virtualspace, mps_tensors))
     for i in eachindex(vspaces)
         vspaces[i] == right_virtualspace(mps_tensors[i - 1]) ||
             throw(SpaceMismatch("incompatible spaces between site $(i - 1) and $i"))
@@ -423,14 +430,14 @@ function makefullrank!(manifold::FiniteMPSManifold)
     # left-to-right sweep
     for site in 1:length(manifold)
         if !isfullrank(manifold[site]; side = :right)
-            maxspace = fuse(left_virtualspace(manifold, i), fuse(physicalspace(manifold, site)))
+            maxspace = fuse(left_virtualspace(manifold, site), fuse(physicalspace(manifold, site)))
             manifold.vspaces[site + 1] = infimum(right_virtualspace(manifold, site), maxspace)
         end
     end
     # right-to-left sweep
     for site in reverse(1:length(manifold))
         if !isfullrank(manifold[site]; side = :left)
-            maxspace = fuse(right_virtualspace(manifold, i), dual(fuse(physicalspace(manifold, site))))
+            maxspace = fuse(right_virtualspace(manifold, site), dual(fuse(physicalspace(manifold, site))))
             manifold.vspaces[site] = infimum(left_virtualspace(manifold, site), maxspace)
         end
     end
@@ -443,15 +450,15 @@ function makefullrank!(manifold::InfiniteMPSManifold)
         # left-to-right sweep
         for site in 1:length(manifold)
             if !isfullrank(manifold[site]; side = :right)
-                maxspace = fuse(left_virtualspace(manifold, i), fuse(physicalspace(manifold, site)))
+                maxspace = fuse(left_virtualspace(manifold, site), fuse(physicalspace(manifold, site)))
                 manifold.vspaces[site + 1] = infimum(right_virtualspace(manifold, site), maxspace)
                 haschanged = true
             end
         end
         # right-to-left sweep
         for site in reverse(1:length(manifold))
             if !isfullrank(manifold[site]; side = :left)
-                maxspace = fuse(right_virtualspace(manifold, i), dual(fuse(physicalspace(manifold, site))))
+                maxspace = fuse(right_virtualspace(manifold, site), dual(fuse(physicalspace(manifold, site))))
                 manifold.vspaces[site] = infimum(left_virtualspace(manifold, site), maxspace)
                 haschanged = true
             end
diff --git a/src/states/finitemps.jl b/src/states/finitemps.jl
@@ -92,13 +92,13 @@ function FiniteMPS(
     # determine the MPS manifold from the input and instantiate the MPS
     mps_tensors = map(ALs, ARs, ACs) do AL, AR, AC
         mps_tensor = coalesce(AL, AR, AC)
-        ismissing(sitetensor) && throw(ArgumentError("missing site tensor at site $i"))
+        ismissing(mps_tensor) && throw(ArgumentError("missing site tensor at site $i"))
         return mps_tensor
     end
     manifold = FiniteMPSManifold(mps_tensors)
     A = _not_missing_type(MA)
     B = _not_missing_type(MB)
-    mps = FiniteMPS{A, B}(undef, manifold)
+    mps = FiniteMPS{A, B}(undef, length(manifold))
 
     # populate the non-missing tensors into the MPS
     for i in 1:L
@@ -116,13 +116,15 @@ function FiniteMPS(
             getfield(mps, :ACs)[i] = ACs[i]
         end
         if !ismissing(Cs[i])
-            space(Cs[i]) == left_virtualspace(V_mps) ← left_virtualspace(V_mps) ||
+            V = left_virtualspace(manifold, i)
+            space(Cs[i]) == (V ← V) ||
                 throw(SpaceMismatch("incompatible space for C[$i]"))
             getfield(mps, :Cs)[i] = Cs[i]
         end
     end
     if !ismissing(Cs[end])
-        space(Cs[end]) == right_virtualspace(manifold, L) ← right_virtualspace(manifold, L) ||
+        V = right_virtualspace(manifold, L)
+        space(Cs[end]) == (V ← V) ||
             throw(SpaceMismatch("incompatible space for C[$(L + 1)]"))
         getfield(mps, :Cs)[L + 1] = Cs[L + 1]
     end
@@ -198,7 +200,7 @@ function FiniteMPS(As::Vector{<:GenericMPSTensor}; normalize::Bool = false)
     mps = FiniteMPS
 
     # start with first in case eltype changes
-    AL1, C = qr_compact(As[i])
+    AL1, C = qr_compact(first(As))
     normalize && normalize!(C)
 
     # instantiate the destination
@@ -225,7 +227,7 @@ function FiniteMPS(ψ::AbstractTensor)
     A = _transpose_front(
         U * transpose(ψ * U', ((), reverse(ntuple(identity, numind(ψ) + 1))))
     )
-    return FiniteMPS(decompose_localmps(A); normalize = false, overwrite = true)
+    return FiniteMPS(decompose_localmps(A); normalize = false)
 end
 
 for f in (:zeros, :ones)
@@ -239,12 +241,12 @@ for f in (:zeros, :ones)
 end
 
 for randfun in (:rand, :randn)
-    randfun! = Symbol(randf, :!)
-    @eval function $randfun(rng::Random.AbstractRNG, ::Type{T}, manifold::FiniteMPSManifold) where {T}
+    randfun! = Symbol(randfun, :!)
+    @eval function Random.$randfun(rng::Random.AbstractRNG, ::Type{T}, manifold::FiniteMPSManifold) where {T}
         As = map(i -> $randfun(rng, T, manifold[i]), 1:length(manifold))
         return normalize!(FiniteMPS(As))
     end
-    @eval function $randfun!(rng::Random.AbstractRNG, mps::FiniteMPS)
+    @eval function Random.$randfun!(rng::Random.AbstractRNG, mps::FiniteMPS)
         for i in 1:length(mps)
             mps.AC[i] = $randfun!(rng, mps.AC[i])
         end
@@ -264,7 +266,7 @@ Base.@deprecate(
     FiniteMPS(
         f, elt, Pspaces::Vector{<:TensorSpace{S}}, maxVspace::S; left::S = oneunit(S), right::S = oneunit(S)
     ) where {S <: ElementarySpace},
-    f(elt, FiniteMPSManifold(Pspaces, maxVspaces; left_virtualspace = left, right_virtualspace = right))
+    f(elt, FiniteMPSManifold(Pspaces, maxVspace; left_virtualspace = left, right_virtualspace = right))
 )
 Base.@deprecate(
     FiniteMPS(
@@ -274,13 +276,13 @@ Base.@deprecate(
 )
 Base.@deprecate(
     FiniteMPS(
-        f, elt, N::Int, V::VectorSpace, args...; left::S = oneunit(S), right::S = oneunit(S)
+        f, elt, N::Int, V::TensorSpace{S}, args...; left::S = oneunit(S), right::S = oneunit(S)
     ) where {S <: ElementarySpace},
     f(elt, FiniteMPSManifold(fill(V, N), args...; left_virtualspace = left, right_virtualspace = right))
 )
 Base.@deprecate(
     FiniteMPS(
-        N::Int, V::VectorSpace, args...; left::S = oneunit(S), right::S = oneunit(S)
+        N::Int, V::TensorSpace{S}, args...; left::S = oneunit(S), right::S = oneunit(S)
     ) where {S <: ElementarySpace},
     rand(FiniteMPSManifold(fill(V, N), args...; left_virtualspace = left, right_virtualspace = right))
 )
diff --git a/src/states/infinitemps.jl b/src/states/infinitemps.jl
@@ -153,7 +153,7 @@ function InfiniteMPS(A::AbstractVector{<:GenericMPSTensor}; kwargs...)
         @warn "Constructing an MPS from tensors that are not full rank"
     makefullrank!(A_copy)
 
-    manifold = InfiniteMPSManifold(A)
+    manifold = InfiniteMPSManifold(A_copy)
     ψ = InfiniteMPS{eltype(A)}(undef, manifold)
 
     # gaugefix the MPS
@@ -170,6 +170,7 @@ function InfiniteMPS(AL::AbstractVector{<:GenericMPSTensor}, C₀::MPSBondTensor
 
     all(isfullrank, AL) || @error "Constructing an MPS from tensors that are not full rank"
     ψ = InfiniteMPS{eltype(AL)}(undef, InfiniteMPSManifold(AL))
+    ψ.AL .= AL
 
     # gaugefix the MPS
     gaugefix!(ψ, AL, C₀; order = :R, kwargs...)
@@ -183,6 +184,7 @@ function InfiniteMPS(C₀::MPSBondTensor, AR::AbstractVector{<:GenericMPSTensor}
 
     all(isfullrank, AR) || @error "Constructing an MPS from tensors that are not full rank"
     ψ = InfiniteMPS{eltype(AR)}(undef, InfiniteMPSManifold(AR))
+    ψ.AR .= AR
 
     # gaugefix the MPS
     gaugefix!(ψ, AR, C₀; order = :L, kwargs...)
@@ -192,12 +194,12 @@ function InfiniteMPS(C₀::MPSBondTensor, AR::AbstractVector{<:GenericMPSTensor}
 end
 
 for randfun in (:rand, :randn)
-    randfun! = Symbol(randf, :!)
-    @eval function $randfun(rng::Random.AbstractRNG, T::Type, manifold::InfiniteMPSManifold; kwargs...)
+    randfun! = Symbol(randfun, :!)
+    @eval function Random.$randfun(rng::Random.AbstractRNG, T::Type, manifold::InfiniteMPSManifold; kwargs...)
         As = map(i -> $randfun(rng, T, manifold[i]), 1:length(manifold))
         return InfiniteMPS(As; kwargs...)
     end
-    @eval function $randfun!(rng::Random.AbstractRNG, mps::InfiniteMPS)
+    @eval function Random.$randfun!(rng::Random.AbstractRNG, mps::InfiniteMPS)
         foreach(Base.Fix1(rng, $randfun!), mps.AC)
         C₀ = $randfun!(rng, mps.C[0])
         gaugefix!(mps, mps.AC, C₀)
