Customizable cell translation function (#53)

Author: LHerviou

src/ITensorInfiniteMPS.jl

@@ -35,6 +35,7 @@ include("infinitecanonicalmps.jl")
 include("infinitempomatrix.jl")
 include("transfermatrix.jl")
 include("models/models.jl")
+include("models/fqhe13.jl")
 include("models/ising.jl")
 include("models/ising_extended.jl")
 include("models/heisenberg.jl")
@@ -73,6 +74,7 @@ export Cell,
   reference,
   subspace_expansion,
   translatecell,
+  translator,
   tdvp,
   vumps,
   ⊕,

src/abstractinfinitemps.jl

@@ -16,17 +16,35 @@ function (T::Type{MPST})(
   return MPST(data, llim, rlim, false)
 end
 
+function (T::Type{MPST})(
+  data::CelledVector{<:ITensor,F}, llim, rlim
+) where {MPST<:AbstractInfiniteMPS,F}
+  return MPST(data, llim, rlim, false)
+end
+
 # TODO: use InfiniteMPS(data, -∞, ∞) when AbstractMPS
 # is written more generically
 function (T::Type{MPST})(data::Vector{<:ITensor}) where {MPST<:AbstractInfiniteMPS}
   return MPST(data, 0, length(data) + 1)
 end
 
+function (T::Type{MPST})(
+  data::Vector{<:ITensor}, translator::Function
+) where {MPST<:AbstractInfiniteMPS}
+  return MPST(CelledVector(data, translator), 0, length(data) + 1)
+end
+
 # TODO: better way to determine left and right limits
 function (T::Type{MPST})(ψ::MPS; reverse::Bool=false) where {MPST<:AbstractInfiniteMPS}
   return MPST(ITensors.data(ψ), ψ.llim, ψ.rlim, reverse)
 end
 
+function (T::Type{MPST})(
+  ψ::MPS, translator::Function; reverse::Bool=false
+) where {MPST<:AbstractInfiniteMPS}
+  return MPST(CelledVector(ITensors.data(ψ), translator), ψ.llim, ψ.rlim, reverse)
+end
+
 # TODO: better way to determine left and right limits
 function (T::Type{MPST})(
   ψ::MPS, llim::Integer, rlim::Integer; reverse::Bool=false
@@ -38,6 +56,12 @@ function (T::Type{MPST})(N::Integer; reverse::Bool=false) where {MPST<:AbstractI
   return MPST(MPS(N); reverse=reverse)
 end
 
+function (T::Type{MPST})(
+  N::Integer, translator::Function; reverse::Bool=false
+) where {MPST<:AbstractInfiniteMPS}
+  return MPST(MPS(N), translator; reverse=reverse)
+end
+
 function Base.reverse(ψ::MPST) where {MPST<:AbstractInfiniteMPS}
   return MPST(reverse(ψ.data), ψ.rlim, ψ.llim, !ψ.reverse)
 end
@@ -94,13 +118,13 @@ _setindex_cell1!(ψ::AbstractInfiniteMPS, val, n::Integer) = (ITensors.data(ψ)[
 function getindex(ψ::AbstractInfiniteMPS, n::Integer)
   cellₙ = cell(ψ, n)
   siteₙ = cellsite(ψ, n)
-  return translatecell(_getindex_cell1(ψ, siteₙ), cellₙ - 1)
+  return translatecell(translator(ψ), _getindex_cell1(ψ, siteₙ), cellₙ - 1)
 end
 
 function setindex!(ψ::AbstractInfiniteMPS, T::ITensor, n::Int)
   cellₙ = cell(ψ, n)
   siteₙ = cellsite(ψ, n)
-  _setindex_cell1!(ψ, translatecell(T, -(cellₙ - 1)), siteₙ)
+  _setindex_cell1!(ψ, translatecell(translator(ψ), T, -(cellₙ - 1)), siteₙ)
   return ψ
 end
 
@@ -154,12 +178,12 @@ end
 # MPS from an InfiniteMPS
 function ITensors.prime(::typeof(linkinds), ψ::AbstractInfiniteMPS)
   ψextended′ = prime(linkinds, ψ[0:(nsites(ψ) + 1)])
-  return typeof(ψ)(ψextended′[2:(end - 1)]; reverse=ψ.reverse)
+  return typeof(ψ)(ψextended′[2:(end - 1)], translator(ψ); reverse=ψ.reverse)
 end
 
 function ITensors.dag(ψ::AbstractInfiniteMPS)
   ψdag = dag(ψ[1:nsites(ψ)])
-  return typeof(ψ)(ψdag; reverse=ψ.reverse)
+  return typeof(ψ)(ψdag, translator(ψ); reverse=ψ.reverse)
 end
 
 ITensors.linkinds(ψ::AbstractInfiniteMPS, n1n2) = linkinds(ψ, Pair(n1n2...))
@@ -206,10 +230,10 @@ end
 
 function ITensors.linkinds(f::typeof(only), ψ::AbstractInfiniteMPS)
   N = nsites(ψ)
-  return CelledVector([f(commoninds(ψ[n], ψ[n + 1])) for n in 1:N])
+  return CelledVector([f(commoninds(ψ[n], ψ[n + 1])) for n in 1:N], translator(ψ))
 end
 
 function ITensors.siteinds(f::typeof(only), ψ::AbstractInfiniteMPS)
   N = nsites(ψ)
-  return CelledVector([f(uniqueinds(ψ[n], ψ[n - 1], ψ[n + 1])) for n in 1:N])
+  return CelledVector([f(uniqueinds(ψ[n], ψ[n - 1], ψ[n + 1])) for n in 1:N], translator(ψ))
 end

src/celledvectors.jl

@@ -36,39 +36,68 @@ function getsite(ts::TagSet)
   return parse(Int, celltag[(length(indextagprefix()) + 1):end])
 end
 
-function translatecell(ts::TagSet, n::Integer)
+##Translation operators
+
+#Default translate cell
+function translatecelltags(ts::TagSet, n::Integer)
   ncell = getcell(ts)
   if isnothing(ncell)
     return ts
   end
   return replacetags(ts, celltags(ncell) => celltags(ncell + n))
 end
 
-function translatecell(i::Index, n::Integer)
+function translatecelltags(i::Index, n::Integer)
   ts = tags(i)
-  translated_ts = translatecell(ts, n)
+  translated_ts = translatecelltags(ts, n)
   return replacetags(i, ts => translated_ts)
 end
 
-function translatecell(is::Union{<:Tuple,<:Vector}, n::Integer)
-  return translatecell.(is, n)
+#Transfer the functional properties
+#translatecell(translator, T::ITensor, n::Integer) = translator(T, n)
+function translatecell(translator::Function, T::ITensor, n::Integer)
+  return ITensors.setinds(T, translatecell(translator, inds(T), n))
+end
+translatecell(translator::Function, T::MPO, n::Integer) = translatecell.(translator, T, n)
+function translatecell(translator::Function, T::Matrix{ITensor}, n::Integer)
+  return translatecell.(translator, T, n)
+end
+translatecell(translator::Function, i::Index, n::Integer) = translator(i, n)
+function translatecell(translator::Function, is::Union{<:Tuple,<:Vector}, n::Integer)
+  return translatecell.(translator, is, n)
 end
 
-translatecell(T::ITensor, n::Integer) = ITensors.setinds(T, translatecell(inds(T), n))
-translatecell(T::MPO, n::Integer) = translatecell.(T, n)
-translatecell(T::Matrix{ITensor}, n::Integer) = translatecell.(T, n)
+#Default behavior
+#translatecell(T::ITensor, n::Integer) = ITensors.setinds(T, translatecell(inds(T), n))
+#translatecell(T::MPO, n::Integer) = translatecell.(T, n)
+#translatecell(T::Matrix{ITensor}, n::Integer) = translatecell.(T, n)
 
-struct CelledVector{T} <: AbstractVector{T}
+struct CelledVector{T,F} <: AbstractVector{T}
   data::Vector{T}
+  translator::F
 end
 ITensors.data(cv::CelledVector) = cv.data
+translator(cv::CelledVector) = cv.translator
 
+Base.copy(m::CelledVector) = typeof(m)(copy(m.data), m.translator) #needed to carry the translator when copying
+Base.deepcopy(m::CelledVector) = typeof(m)(deepcopy(m.data), m.translator) #needed to carry the translator when copying
 Base.convert(::Type{CelledVector{T}}, v::Vector) where {T} = CelledVector{T}(v)
 
 function CelledVector{T}(::UndefInitializer, n::Integer) where {T}
   return CelledVector(Vector{T}(undef, n))
 end
 
+function CelledVector{T}(::UndefInitializer, n::Integer, translator::Function) where {T}
+  return CelledVector(Vector{T}(undef, n), translator::Function)
+end
+CelledVector(v::AbstractVector) = CelledVector(v, translatecelltags)
+function CelledVector{T}(v::Vector{T}) where {T}
+  return CelledVector(v, translatecelltags)
+end
+function CelledVector{T}(v::Vector{T}, translator::Function) where {T}
+  return CelledVector(v, translator)
+end
+
 """
     celllength(cv::CelledVector)
 
@@ -105,12 +134,12 @@ _getindex_cell1(cv::CelledVector, n::Int) = ITensors.data(cv)[n]
 _setindex_cell1!(cv::CelledVector, val, n::Int) = (ITensors.data(cv)[n] = val)
 
 # Fallback
-translatecell(x, ::Integer) = x
+#translatecell(x, ::Integer) = x # I think this is useless now
 
 function getindex(cv::CelledVector, n::Int)
   cellₙ = cell(cv, n)
   siteₙ = cellindex(cv, n)
-  return translatecell(_getindex_cell1(cv, siteₙ), cellₙ - 1)
+  return translatecell(cv.translator, _getindex_cell1(cv, siteₙ), cellₙ - 1)
 end
 
 # Do we need this definition? Maybe uses generic Julia fallback
@@ -137,44 +166,8 @@ getindex(cv::CelledVector, c::Cell) = cv[eachindex(cv, c)]
 function setindex!(cv::CelledVector, T, n::Int)
   cellₙ = cell(cv, n)
   siteₙ = cellindex(cv, n)
-  _setindex_cell1!(cv, translatecell(T, -(cellₙ - 1)), siteₙ)
+  _setindex_cell1!(cv, translatecell(cv.translator, T, -(cellₙ - 1)), siteₙ)
   return cv
 end
 
 celltags(cell) = TagSet("c=$cell")
-
-#
-# TODO: This version accepts a more general translation function between
-# unit cells
-#
-
-#struct CelledVector{T, F, FINV} <: AbstractVector{T}
-#  data::Vector{T}
-#  f::F
-#end
-#
-#CelledVector(v::AbstractVector) = CelledVector(v, identity)
-#
-#cell_length(cv::CelledVector) = length(cv.data)
-#
-## Determine which cell the index is in
-#cell(cv::CelledVector, n::Integer) = fld1(n, cell_length(cv))
-#
-## Determine the index in the cell where the index sits
-#cell_index(cv::CelledVector, n::Integer) = mod1(n, cell_length(cv))
-#
-## Return the cell and the cell index
-#cell_and_cell_index(cv::CelledVector, n::Integer) = fldmod1(n, cell_length(cv))
-#
-#function getindex(cv::CelledVector, n::Integer)
-#  cellₙ, cell_indexₙ = cell_and_cell_index(cv, n)
-#  return cv.f(cv.data[cell_indexₙ], cellₙ)
-#end
-#
-#function setindex!(cv::CelledVector, val, n::Integer)
-#  cellₙ, cell_indexₙ = cell_and_cell_index(cv, n)
-#  # XXX: is this offset generally correct?
-#  # It seems to be for "linear" functions.
-#  cv.data[cell_indexₙ] = cv.f(val, -cellₙ + 2)
-#  return cv
-#end

src/infinitecanonicalmps.jl

@@ -26,25 +26,37 @@ function __siteinds(site_tag, N::Int, space)
 end
 
 infsiteinds(s::Vector{<:Index}) = CelledVector(addtags(s, celltags(1)))
-function infsiteinds(site_tag, N::Int; space=nothing, kwargs...)
+function infsiteinds(s::Vector{<:Index}, translator)
+  return CelledVector(addtags(s, celltags(1)), translator)
+end
+
+function infsiteinds(site_tag, N::Int; space=nothing, translator=nothing, kwargs...)
   if !isnothing(space)
     s = _siteinds(site_tag, N; space=space)
   else
     # TODO: add a shift option
     s = siteinds(site_tag, N; kwargs...)
   end
-  return infsiteinds(s)
+  if !isnothing(translator)
+    return infsiteinds(s, translator)
+  else
+    return infsiteinds(s)
+  end
 end
 
 function ITensors.linkinds(ψ::InfiniteMPS)
   N = nsites(ψ)
-  return CelledVector([linkinds(ψ, (n, n + 1)) for n in 1:N])
+  return CelledVector([linkinds(ψ, (n, n + 1)) for n in 1:N], translator(ψ))
 end
 
 function InfMPS(s::Vector, f::Function)
   return InfMPS(infsiteinds(s), f)
 end
 
+function InfMPS(s::Vector, f::Function, translator::Function)
+  return InfMPS(infsiteinds(s, translator), f)
+end
+
 function indval(iv::Pair)
   return ind(iv) => val(iv)
 end
@@ -56,7 +68,7 @@ end
 function insert_linkinds!(A; left_dir=ITensors.Out)
   # TODO: use `celllength` here
   N = nsites(A)
-  l = CelledVector{indtype(A)}(undef, N)
+  l = CelledVector{indtype(A)}(undef, N, translator(A))
   n = N
   s = siteind(A, 1)
   dim = if hasqns(s)
@@ -89,7 +101,8 @@ end
 
 function UniformMPS(s::CelledVector, f::Function; left_dir=ITensors.Out)
   sᶜ¹ = s[Cell(1)]
-  A = InfiniteMPS([ITensor(sⁿ) for sⁿ in sᶜ¹])
+  A = InfiniteMPS([ITensor(sⁿ) for sⁿ in sᶜ¹], translator(s))
+  #A.data.translator = translator(s)
   N = length(sᶜ¹)
   for n in 1:N
     Aⁿ = A[n]
@@ -105,7 +118,7 @@ function InfMPS(s::CelledVector, f::Function)
   N = length(s)
   ψL = UniformMPS(s, f; left_dir=ITensors.Out)
   ψR = UniformMPS(s, f; left_dir=ITensors.In)
-  ψC = InfiniteMPS(N)
+  ψC = InfiniteMPS(N, translator(s))
   l = linkinds(ψL)
   r = linkinds(ψR)
   for n in 1:N

src/infinitempo.jl

@@ -18,3 +18,5 @@ end
 ## getindex(l::InfiniteSumLocalOps, n::Integer) = ITensors.data(l)[n]
 
 # TODO? Instead of having a big quasi empty ITensor, store only the non zero blocks
+
+translator(mpo::InfiniteMPO) = mpo.data.translator

src/infinitempomatrix.jl

@@ -6,6 +6,8 @@ mutable struct InfiniteMPOMatrix <: AbstractInfiniteMPS
   reverse::Bool
 end
 
+translator(mpo::InfiniteMPOMatrix) = mpo.data.translator
+
 # TODO better printing?
 function Base.show(io::IO, M::InfiniteMPOMatrix)
   print(io, "$(typeof(M))")
@@ -37,4 +39,8 @@ function InfiniteMPOMatrix(arrMat::Vector{Matrix{ITensor}})
   return InfiniteMPOMatrix(arrMat, 0, size(arrMat)[1], false)
 end
 
+function InfiniteMPOMatrix(data::Vector{Matrix{ITensor}}, translator::Function)
+  return InfiniteMPOMatrix(CelledVector(data, translator), 0, size(data)[1], false)
+end
+
 #nrange(H::InfiniteMPOMatrix) = [size(H[j])[1] - 1 for j in 1:nsites(H)]