Merge branch 'main' into indexchange

ryanlevy · ryanlevy · commit 0b688d69a8f2 · 2025-02-17T20:23:00.000-05:00
diff --git a/Project.toml b/Project.toml
@@ -19,8 +19,8 @@ SplitApplyCombine = "03a91e81-4c3e-53e1-a0a4-9c0c8f19dd66"
 [compat]
 Compat = "3, 4"
 HDF5 = "0.15, 0.16, 0.17"
-ITensorMPS = "0.2.2"
-ITensors = "0.6.8"
+ITensorMPS = "0.3"
+ITensors = "0.7"
 Infinities = "0.1"
 IterTools = "1"
 KrylovKit = "0.5, 0.6, 0.7, 0.8"
diff --git a/examples/development/vumps/transfer_matrix_spectrum_arpack.jl b/examples/development/vumps/transfer_matrix_spectrum_arpack.jl
@@ -75,7 +75,7 @@ function energy_local(ψ1, ψ2, h)
   return (noprime(ϕ * h) * dag(ϕ))[]
 end
 
-function ITensors.expect(ψ, o)
+function ITensorMPS.expect(ψ, o)
   return (noprime(ψ * op(o, filterinds(ψ, "Site")...)) * dag(ψ))[]
 end
 
diff --git a/examples/vumps/transfer_matrix_spectrum.jl b/examples/vumps/transfer_matrix_spectrum.jl
@@ -76,7 +76,7 @@ function energy_local(ψ1, ψ2, h)
   return inner(ϕ, apply(h, ϕ))
 end
 
-function ITensors.expect(ψ::ITensor, o::String)
+function ITensorMPS.expect(ψ::ITensor, o::String)
   return inner(ψ, apply(op(o, filterinds(ψ, "Site")...), ψ))
 end
 
diff --git a/examples/vumps/vumps_2d_heisenberg.jl b/examples/vumps/vumps_2d_heisenberg.jl
@@ -19,6 +19,7 @@ conserve_qns = true
 solver_tol = (x -> x / 10)
 outer_iters = 10 # Number of times to increase the bond dimension
 width = 4
+yperiodic = false # OBC vs cylinder
 
 ##############################################################################
 # CODE BELOW HERE DOES NOT NEED TO BE MODIFIED
@@ -30,24 +31,29 @@ initstate(n) = isodd(n) ? "↑" : "↓"
 s = infsiteinds("S=1/2", N; conserve_qns, initstate)
 ψ = InfMPS(s, initstate)
 
-function ITensorInfiniteMPS.unit_cell_terms(::Model"heisenberg2D"; width)
+function ITensorInfiniteMPS.unit_cell_terms(::Model"heisenberg2D"; width, yperiodic)
   opsum = OpSum()
   for i in 1:width
     # Vertical
-    opsum += -0.5, "S+", i, "S-", mod(i + 1, width)
-    opsum += -0.5, "S-", i, "S+", mod(i + 1, width)
-    opsum += "Sz", i, "Sz", mod(i + 1, width)
+    opsum -= 0.5, "S+", i, "S-", i + 1
+    opsum -= 0.5, "S-", i, "S+", i + 1
+    opsum += "Sz", i, "Sz", i + 1
     # Horizontal
-    opsum += -0.5, "S+", i, "S-", i + width
-    opsum += -0.5, "S-", i, "S+", i + width
+    opsum -= 0.5, "S+", i, "S-", i + width
+    opsum -= 0.5, "S-", i, "S+", i + width
     opsum += "Sz", i, "Sz", i + width
   end
+  if yperiodic
+    opsum -= 0.5, "S+", 1, "S-", width
+    opsum -= 0.5, "S-", 1, "S+", width
+    opsum += "Sz", 1, "Sz", width
+  end
   return opsum
 end
 model = Model("heisenberg2D")
 
 # Form the Hamiltonian
-H = InfiniteSum{MPO}(model, s; width)
+H = InfiniteSum{MPO}(model, s; width, yperiodic)
 
 # Check translational invariance
 # println("\nCheck translation invariance of the initial VUMPS state")
diff --git a/examples/vumps/vumps_heisenberg.jl b/examples/vumps/vumps_heisenberg.jl
@@ -79,7 +79,7 @@ energy_finite_total, ψfinite = dmrg(Hfinite, ψfinite; nsweeps, maxdim, cutoff)
 
 energy_exact_finite = reference(model, Observable("energy"); N=Nfinite)
 
-function ITensors.expect(ψ::ITensor, o::String)
+function ITensorMPS.expect(ψ::ITensor, o::String)
   return inner(ψ, apply(op(o, filterinds(ψ, "Site")...), ψ))
 end
 
diff --git a/examples/vumps/vumps_hubbard_extended.jl b/examples/vumps/vumps_hubbard_extended.jl
@@ -114,9 +114,9 @@ bsfinite = [(nfinite, nfinite + 1), (nfinite + 1, nfinite + 2)]
 hfinite(b) = ITensor(model, [sfinite[b[1]], sfinite[b[2]]]; model_params...)
 energy_finite = map(b -> expect_two_site(ψfinite, hfinite(b), b), bsfinite)
 
-Nup_finite = ITensors.expect(ψfinite, "Nup")[nfinite:(nfinite + 1)]
-Ndn_finite = ITensors.expect(ψfinite, "Ndn")[nfinite:(nfinite + 1)]
-Sz_finite = ITensors.expect(ψfinite, "Sz")[nfinite:(nfinite + 1)]
+Nup_finite = ITensorMPS.expect(ψfinite, "Nup")[nfinite:(nfinite + 1)]
+Ndn_finite = ITensorMPS.expect(ψfinite, "Ndn")[nfinite:(nfinite + 1)]
+Sz_finite = ITensorMPS.expect(ψfinite, "Sz")[nfinite:(nfinite + 1)]
 
 energy_exact = reference(model, Observable("energy"); U=model_params.U / model_params.t)
 
diff --git a/examples/vumps/vumps_ising.jl b/examples/vumps/vumps_ising.jl
@@ -77,7 +77,7 @@ end
 
 energy_local(ψ1, ψ2, h::MPO) = energy_local(ψ1, ψ2, prod(h))
 
-function ITensors.expect(ψ, o)
+function ITensorMPS.expect(ψ, o)
   return (noprime(ψ * op(o, filterinds(ψ, "Site")...)) * dag(ψ))[]
 end
 
diff --git a/src/ITensorInfiniteMPS.jl b/src/ITensorInfiniteMPS.jl
@@ -23,7 +23,8 @@ using KrylovKit: eigsolve, linsolve, exponentiate
 
 import Base: getindex, length, setindex!, +, -, *
 
-import ITensors: AbstractMPS, ⊕
+using ITensorMPS: AbstractMPS
+import ITensors: ⊕
 
 include("ITensors.jl")
 include("itensormap.jl")
diff --git a/src/abstractinfinitemps.jl b/src/abstractinfinitemps.jl
@@ -186,26 +186,26 @@ function ITensors.dag(ψ::AbstractInfiniteMPS)
   return typeof(ψ)(ψdag, translator(ψ); reverse=ψ.reverse)
 end
 
-ITensors.linkinds(ψ::AbstractInfiniteMPS, n1n2) = linkinds(ψ, Pair(n1n2...))
+ITensorMPS.linkinds(ψ::AbstractInfiniteMPS, n1n2) = linkinds(ψ, Pair(n1n2...))
 
-function ITensors.linkinds(ψ::AbstractInfiniteMPS, n1n2::Pair{<:Integer,<:Integer})
+function ITensorMPS.linkinds(ψ::AbstractInfiniteMPS, n1n2::Pair{<:Integer,<:Integer})
   return commoninds(ψ[n1n2[1]], ψ[n1n2[2]])
 end
 
-function ITensors.linkind(ψ::AbstractInfiniteMPS, n1n2::Pair{<:Integer,<:Integer})
+function ITensorMPS.linkind(ψ::AbstractInfiniteMPS, n1n2::Pair{<:Integer,<:Integer})
   return commonind(ψ[n1n2[1]], ψ[n1n2[2]])
 end
 
-function ITensors.siteind(ψ::AbstractInfiniteMPS, n::Integer)
+function ITensorMPS.siteind(ψ::AbstractInfiniteMPS, n::Integer)
   return uniqueind(ψ[n], ψ[n - 1], ψ[n + 1])
 end
 
-function ITensors.siteinds(ψ::AbstractInfiniteMPS, n::Integer)
+function ITensorMPS.siteinds(ψ::AbstractInfiniteMPS, n::Integer)
   return uniqueinds(ψ[n], ψ[n - 1], ψ[n + 1])
 end
 
 # TODO: return a Dictionary or IndexSetNetwork?
-function ITensors.siteinds(ψ::AbstractInfiniteMPS, r::AbstractRange)
+function ITensorMPS.siteinds(ψ::AbstractInfiniteMPS, r::AbstractRange)
   return [siteind(ψ, n) for n in r]
 end
 
@@ -216,9 +216,9 @@ function siterange(ψ::AbstractInfiniteMPS, c::Cell)
   return start:stop
 end
 
-ITensors.siteinds(ψ::AbstractInfiniteMPS, c::Cell) = siteinds(ψ, siterange(ψ, c))
+ITensorMPS.siteinds(ψ::AbstractInfiniteMPS, c::Cell) = siteinds(ψ, siterange(ψ, c))
 
-function ITensors.siteinds(ψ::AbstractInfiniteMPS)
+function ITensorMPS.siteinds(ψ::AbstractInfiniteMPS)
   return CelledVector(siteinds(ψ, Cell(1)), translator(ψ))
 end
 infsiteinds(ψ::AbstractInfiniteMPS) = siteinds(ψ)
@@ -238,12 +238,12 @@ end
 
 (::Colon)(n::Int, f::typeof(nsites)) = UnitRangeToFunction(n, f)
 
-function ITensors.linkinds(f::typeof(only), ψ::AbstractInfiniteMPS)
+function ITensorMPS.linkinds(f::typeof(only), ψ::AbstractInfiniteMPS)
   N = nsites(ψ)
   return CelledVector([f(commoninds(ψ[n], ψ[n + 1])) for n in 1:N], translator(ψ))
 end
 
-function ITensors.siteinds(f::typeof(only), ψ::AbstractInfiniteMPS)
+function ITensorMPS.siteinds(f::typeof(only), ψ::AbstractInfiniteMPS)
   N = nsites(ψ)
   return CelledVector([f(uniqueinds(ψ[n], ψ[n - 1], ψ[n + 1])) for n in 1:N], translator(ψ))
 end
diff --git a/src/infinitecanonicalmps.jl b/src/infinitecanonicalmps.jl
@@ -166,7 +166,7 @@ function infsiteinds(
   return infsiteinds(s, translator)
 end
 
-function ITensors.linkinds(ψ::InfiniteMPS)
+function ITensorMPS.linkinds(ψ::InfiniteMPS)
   N = nsites(ψ)
   return CelledVector([linkinds(ψ, (n, n + 1)) for n in 1:N], translator(ψ))
 end
@@ -266,14 +266,14 @@ function finite_mps(ψ::InfiniteCanonicalMPS, range::AbstractRange)
   set_ortho_lims!(ψ_finite, (N + 1):(N + 1))
   return ψ_finite
 end
-function ITensors.expect(ψ::InfiniteCanonicalMPS, o::String, n::Int)
+function ITensorMPS.expect(ψ::InfiniteCanonicalMPS, o::String, n::Int)
   s = siteinds(only, ψ.AL)
   O = op(o, s[n])
   ϕ = ψ.AL[n] * ψ.C[n]
   return inner(ϕ, apply(O, ϕ))
 end
 
-function ITensors.expect(ψ::InfiniteCanonicalMPS, h::MPO)
+function ITensorMPS.expect(ψ::InfiniteCanonicalMPS, h::MPO)
   l = linkinds(ITensorInfiniteMPS.only, ψ.AL)
   r = linkinds(ITensorInfiniteMPS.only, ψ.AR)
   s = siteinds(ITensorInfiniteMPS.only, ψ)
@@ -298,6 +298,6 @@ function ITensors.expect(ψ::InfiniteCanonicalMPS, h::MPO)
   return temp_O[]
 end
 
-function ITensors.expect(ψ::InfiniteCanonicalMPS, h::InfiniteSum)
+function ITensorMPS.expect(ψ::InfiniteCanonicalMPS, h::InfiniteSum)
   return [expect(ψ, h[j]) for j in 1:nsites(ψ)]
 end
diff --git a/src/infinitemps.jl b/src/infinitemps.jl
@@ -57,14 +57,14 @@ function ITensors.dag(ψ::InfiniteCanonicalMPS, args...; kwargs...)
   return fmap(x -> dag(x, args...; kwargs...), ψ)
 end
 
-ITensors.siteinds(f::typeof(only), ψ::InfiniteCanonicalMPS) = siteinds(f, ψ.AL)
+ITensorMPS.siteinds(f::typeof(only), ψ::InfiniteCanonicalMPS) = siteinds(f, ψ.AL)
 
 getcell(i::Index) = ITensorInfiniteMPS.getcell(tags(i))
 getsite(i::Index) = getsite(tags(i))
 
 #Before, for a two site Hamiltonian, findsites(ψ, H[3]) would return [1, 2]
 #Appeared unsafe for index purpose
-function ITensors.findfirstsiteind(ψ::InfiniteMPS, i::Index)
+function ITensorMPS.findfirstsiteind(ψ::InfiniteMPS, i::Index)
   c = ITensorInfiniteMPS.getcell(i)
   n1 = getsite(i)
   # if translator(ψ) == translatecelltags
@@ -95,28 +95,28 @@ function ITensors.findfirstsiteind(ψ::InfiniteMPS, i::Index)
   #   return 0
   # end
 end
-function ITensors.findfirstsiteind(ψ::InfiniteCanonicalMPS, i::Index)
-  return ITensors.findfirstsiteind(ψ.AL, i)
+function ITensorMPS.findfirstsiteind(ψ::InfiniteCanonicalMPS, i::Index)
+  return ITensorMPS.findfirstsiteind(ψ.AL, i)
 end
 
-function ITensors.findsites(ψ::InfiniteCanonicalMPS, is::Union{<:Tuple,<:Vector})
-  return sort([ITensors.findfirstsiteind(ψ, i) for i in is])
+function ITensorMPS.findsites(ψ::InfiniteCanonicalMPS, is::Union{<:Tuple,<:Vector})
+  return sort([ITensorMPS.findfirstsiteind(ψ, i) for i in is])
 end
-function ITensors.findsites(ψ::InfiniteMPS, is::Union{<:Tuple,<:Vector})
-  return sort([ITensors.findfirstsiteind(ψ, i) for i in is])
+function ITensorMPS.findsites(ψ::InfiniteMPS, is::Union{<:Tuple,<:Vector})
+  return sort([ITensorMPS.findfirstsiteind(ψ, i) for i in is])
 end
-function ITensors.findsites(ψ::InfiniteMPS, T::MPO)
+function ITensorMPS.findsites(ψ::InfiniteMPS, T::MPO)
   s = [noprime(filterinds(T[x]; plev=1)[1]) for x in 1:length(T)]
-  return sort([ITensors.findfirstsiteind(ψ, i) for i in s])
+  return sort([ITensorMPS.findfirstsiteind(ψ, i) for i in s])
 end
-ITensors.findsites(ψ::InfiniteCanonicalMPS, T::MPO) = findsites(ψ.AL, T)
+ITensorMPS.findsites(ψ::InfiniteCanonicalMPS, T::MPO) = findsites(ψ.AL, T)
 
 #Kept for historical reason
-function ITensors.findsites(ψ::InfiniteMPS, T::ITensor)
+function ITensorMPS.findsites(ψ::InfiniteMPS, T::ITensor)
   s = filterinds(T; plev=0)
-  return sort([ITensors.findfirstsiteind(ψ, i) for i in s])
+  return sort([ITensorMPS.findfirstsiteind(ψ, i) for i in s])
 end
-ITensors.findsites(ψ::InfiniteCanonicalMPS, T::ITensor) = findsites(ψ.AL, T)
+ITensorMPS.findsites(ψ::InfiniteCanonicalMPS, T::ITensor) = findsites(ψ.AL, T)
 
 # For now, only represents nearest neighbor interactions
 # on a linear chain
@@ -193,20 +193,20 @@ function nrange(h::MPO; ncell=1)
   return ns[end] - ns[1] + 1
 end
 
-ITensors.findsites(h::InfiniteSum) = [findsites(h, n) for n in 1:nsites(h)]
-ITensors.findsites(h::InfiniteSum, n::Int64) = findsites(h.data[n]; ncell=nsites(h))
-#ITensors.findsites(h::InfiniteSum, is::Union{<:Tuple,<:Vector}) = [findsites(h.data[n], is) for n in 1:nsites(h)]
-#ITensors.findsites(h::InfiniteSum, i::Index) = [findsites(h.data[n], i) for n in 1:nsites(h)]
+ITensorMPS.findsites(h::InfiniteSum) = [findsites(h, n) for n in 1:nsites(h)]
+ITensorMPS.findsites(h::InfiniteSum, n::Int64) = findsites(h.data[n]; ncell=nsites(h))
+#ITensorMPS.findsites(h::InfiniteSum, is::Union{<:Tuple,<:Vector}) = [findsites(h.data[n], is) for n in 1:nsites(h)]
+#ITensorMPS.findsites(h::InfiniteSum, i::Index) = [findsites(h.data[n], i) for n in 1:nsites(h)]
 #TODO improve the findsites routines for Infinite Sum
 
-function ITensors.findfirstsiteind(i::Index, ncell::Int64)
+function ITensorMPS.findfirstsiteind(i::Index, ncell::Int64)
   c = ITensorInfiniteMPS.getcell(i)
   n1 = getsite(i)
   return (c - 1) * ncell + n1
 end
-function ITensors.findsites(h::MPO; ncell::Int64=1)
+function ITensorMPS.findsites(h::MPO; ncell::Int64=1)
   s = [filterinds(h[x]; plev=1)[1] for x in 1:length(h)]
-  return sort([ITensors.findfirstsiteind(i, ncell) for i in s])
+  return sort([ITensorMPS.findfirstsiteind(i, ncell) for i in s])
 end
 
 #Kept for historical reasons
@@ -223,14 +223,14 @@ function nrange(ψ::InfiniteCanonicalMPS, h::MPO)
   return ns[end] - ns[1] + 1
 end
 
-function ITensors.findfirstsiteind(h::ITensor, i::Index, ncell::Int64)
+function ITensorMPS.findfirstsiteind(h::ITensor, i::Index, ncell::Int64)
   c = getcell(i)
   n1 = getsite(i)
   return (c - 1) * ncell + n1
 end
-function ITensors.findsites(h::ITensor; ncell::Int64=1)
+function ITensorMPS.findsites(h::ITensor; ncell::Int64=1)
   s = filterinds(h; plev=0)
-  return sort([ITensors.findfirstsiteind(h, i, ncell) for i in s])
+  return sort([ITensorMPS.findfirstsiteind(h, i, ncell) for i in s])
 end
 
 ## HDF5 support for the InfiniteCanonicalMPS type
diff --git a/src/models/models.jl b/src/models/models.jl
@@ -222,7 +222,7 @@ function InfiniteBlockMPO(model::Model, s::CelledVector, translator::Function; k
   return mpos
 end
 
-function ITensors.MPO(model::Model, s::Vector{<:Index}; kwargs...)
+function ITensorMPS.MPO(model::Model, s::Vector{<:Index}; kwargs...)
   opsum = opsum_finite(model, length(s); kwargs...)
   return splitblocks(linkinds, MPO(opsum, s))
 end
@@ -245,6 +245,14 @@ function infinite_terms(opsum::OpSum; kwargs...)
   # stores all terms starting on site `i`.
   opsum_cell_dict = groupreduce(minimum ∘ ITensors.sites, +, opsum)
   nsites = maximum(keys(opsum_cell_dict))
+  # check that we don't have terms we will ignore
+  dropped = filter(x -> x <= 0, keys(opsum_cell_dict))
+  if length(dropped) > 0
+    error(
+      "The input unit cell terms include terms that are being ignored on sites: $([d for d in dropped])",
+    )
+  end
+
   # Assumes each site in the unit cell has a term
   for j in 1:nsites
     if !haskey(opsum_cell_dict, j)
diff --git a/src/orthogonalize.jl b/src/orthogonalize.jl
@@ -113,7 +113,7 @@ function mixed_canonical(
   return InfiniteCanonicalMPS(ψᴸ, C, ψᴿ)
 end
 
-ITensors.orthogonalize(ψ::InfiniteMPS, ::Colon; kwargs...) = mixed_canonical(ψ; kwargs...)
+ITensorMPS.orthogonalize(ψ::InfiniteMPS, ::Colon; kwargs...) = mixed_canonical(ψ; kwargs...)
 
 #TODO put these functions somewhere else
 function ortho_overlap(AC, C)
diff --git a/test/test_iMPOConversions.jl b/test/test_iMPOConversions.jl
@@ -57,7 +57,7 @@ end
 # Terminate and then call expect
 # for inf ψ and finite h, which is already supported in src/infinitecanonicalmps.jl
 #
-function ITensors.expect(ψ::InfiniteCanonicalMPS, h::InfiniteMPO)
+function ITensorMPS.expect(ψ::InfiniteCanonicalMPS, h::InfiniteMPO)
   return expect(ψ, terminate(h)) #defer to src/infinitecanonicalmps.jl
 end
 
@@ -82,7 +82,7 @@ function generate_edges(h::InfiniteBlockMPO)
   return Ls, Rs
 end
 
-function ITensors.expect(ψ::InfiniteCanonicalMPS, h::InfiniteBlockMPO)
+function ITensorMPS.expect(ψ::InfiniteCanonicalMPS, h::InfiniteBlockMPO)
   Ncell = nsites(h)
   L, R = generate_edges(h)
   l = commoninds(ψ.AL[0], ψ.AL[1])
