Rewrite MPS types to use C instead of CR (and CL) and add ψ.center functionality. (#216)

* change `CLs` field to `Cs` field

* update printing

* index changes in `FiniteMPS` constructor

* rename `CRView` to `CView`

* change to `getproperty(::FiniteMPS, :C)` instead of `:CR`

* change `center` field to type `Ref{Int}` to allow for mutable integer in unmutable `FiniteMPS` struct

* update `copy` and `similar` for `FiniteMPS` to include `center` field

* initialize `center` of `FiniteMPS` on the last site

* update `left_virtualspace` and `right_virtualspace` to `psi.C` syntax

* change `orthview.jl` to use new `CView` syntax

* update tests to use `.C` instead of `.CR`

* update `+(::FiniteMPS, ::FiniteMPS)` to new `.C` syntax

* format `orthoview.jl`

* fix `similar` of `center` in `similar(::FiniteMPS)`

* change comment

* add HalfIntegers.jl as dependency

* remove `center` field of `FiniteMPS`

* update `FiniteMPS` docstring

* add `center` function thats accessed through `getproperty`

* rewrite `norm(::FiniteMPS)` without having to guage (implementing 5 year old TODO)

* change `getproperty(::MultilineMPS)` to work with `:C` instead of `:CR`

* change every instance of `.CR` to `.C`

* change `getproperty(::WindowMPS)` to work with `:C` instead of `:CR`

* change index in `norm(::FiniteMPS)`

* use `HalfIntegers.ishalfodd` to determine if center is a bond tensor or center tensor

* add docstring for `center(::FiniteMPS)`

* use `center(psi)` instead of `psi.center` in `norm(::FiniteMPS)`

* update `center(::FiniteMPS)`

* use `center(::FiniteMPS)` in `Base.show(::IOContext, ::FiniteMPS)`

* small `show` fix

* use `isinteger(::HalfInt)` instead of `!ishalfodd(::HalfInt)`

* modify `show(::IOContext, ::FiniteMPS)` using the new `center` `HalfInteger` syntax

* formatter

* get rid of mention to `CL` and `CR` in docs [skip CI]

* docfixes [skip CI]

* small changes in `Base.show(::IOContext, ::FiniteMPS)`

* fix `Base.show(::IOContext, ::FiniteMPS)` edgecases

* formatter

* remove printstatement from docs

* remove `center` as a function, only keep `mps.center` property

* remove commented code

* implement `Base.propertynames(ψ::FiniteMPS)`

* add `Base.propertynames` for `WindowMPS` and `MultilineMPS`

Author: VictorVanthilt

Project.toml

@@ -9,6 +9,7 @@ BlockTensorKit = "5f87ffc2-9cf1-4a46-8172-465d160bd8cd"
 FLoops = "cc61a311-1640-44b5-9fba-1b764f453329"
 FastClosures = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"
 FoldsThreads = "9c68100b-dfe1-47cf-94c8-95104e173443"
+HalfIntegers = "f0d1745a-41c9-11e9-1dd9-e5d34d218721"
 KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LoggingExtras = "e6f89c97-d47a-5376-807f-9c37f3926c36"
@@ -30,6 +31,7 @@ BlockTensorKit = "0.1.1"
 FLoops = "0.1, 0.2"
 FastClosures = "0.3"
 FoldsThreads = "0.1"
+HalfIntegers = "1.6.0"
 KrylovKit = "0.8.3"
 LinearAlgebra = "1.6"
 LoggingExtras = "~1.0"

docs/src/index.md

@@ -71,21 +71,21 @@ represent a vector of these tensors.
 ```@example finitemps
 al = mps.AL[3] # left gauged tensor of the third site
 @tensor E[a; b] := al[c, d, b] * conj(al[c, d, a])
-@show isapprox(E, id(left_virtualspace(mps, 3)))
+@show isapprox(E, id(right_virtualspace(mps, 3)))
 ```
 ```@example finitemps
 ar = mps.AR[3] # right gauged tensor of the third site
 @tensor E[a; b] := ar[a, d, c] * conj(ar[b, d, c])
-@show isapprox(E, id(right_virtualspace(mps, 2)))
+@show isapprox(E, id(left_virtualspace(mps, 3)))
 ```
 
 As the mps will be kept in a gauged form, updating a tensor will also update the gauged
 tensors. For example, we can set the tensor of the third site to the identity, and the
 gauged tensors will be updated accordingly.
 
 ```@example finitemps
-mps.CR[3] = id(domain(mps.CR[3]))
-println(mps)
+mps.C[3] = id(domain(mps.C[3]))
+mps
 ```
 
 These objects can then be used to compute observables and expectation values. For example,
@@ -136,16 +136,16 @@ mps = InfiniteMPS(d, D) # random MPS
 
 The `InfiniteMPS` object then handles the gauging of the MPS, which is necessary for many of
 the algorithms. This is done automatically upon creation of the object, and the user can
-access the gauged tensors by getting and setting the `AL`, `AR`, `CR`/`CL` and `AC` fields,
+access the gauged tensors by getting and setting the `AL`, `AR`, `C` and `AC` fields,
 which each represent a (periodic) vector of these tensors.
 
 ```@example infinitemps
-al = mps.AL[1] # left gauged tensor of the third site
+al = mps.AL[1] # left gauged tensor of the first site
 @tensor E[a; b] := al[c, d, b] * conj(al[c, d, a])
 @show isapprox(E, id(left_virtualspace(mps, 1)))
 ```
 ```@example infinitemps
-ar = mps.AR[1] # right gauged tensor of the third site
+ar = mps.AR[1] # right gauged tensor of the first site
 @tensor E[a; b] := ar[a, d, c] * conj(ar[b, d, c])
 @show isapprox(E, id(right_virtualspace(mps, 2)))
 ```

docs/src/man/states.md

@@ -53,8 +53,8 @@ norm(state) == norm(state.AC[3])
 lastly there is also the CR field, with the following property:
 
 ```julia
-@tensor a[-1 -2;-3] := state.AL[3][-1 -2;1]*state.CR[3][1;-3]
-@tensor b[-1 -2;-3] := state.CR[2][-1;1]*state.AR[3][1 -2;-3]
+@tensor a[-1 -2;-3] := state.AL[3][-1 -2;1]*state.C[3][1;-3]
+@tensor b[-1 -2;-3] := state.C[2][-1;1]*state.AR[3][1 -2;-3]
 a ≈ state.AC[3];
 b ≈ state.AC[3];
 ```
@@ -66,7 +66,7 @@ Behind the scenes, a finite mps has 4 fields
 ALs::Vector{Union{Missing,A}}
 ARs::Vector{Union{Missing,A}}
 ACs::Vector{Union{Missing,A}}
-CLs::Vector{Union{Missing,B}}
+Cs::Vector{Union{Missing,B}}
 ```
 
 calling `state.AC` returns an "orthoview" instance, which is a very simple dummy object.
@@ -97,7 +97,7 @@ InfiniteMPS(data);
 
 The above code would create an infinite mps with an A-B structure (a 2 site unit cell).
 
-much like a finite mps, we can again query the fields state.AL, state.AR, state.AC and state.CR. The implementation is much easier, as they are now just plain fields in the struct
+much like a finite mps, we can again query the fields state.AL, state.AR, state.AC and state.C. The implementation is much easier, as they are now just plain fields in the struct
 
 ```julia
 AL::PeriodicArray{A,1}
@@ -142,7 +142,7 @@ You can access properties by calling
 state.AL[row,collumn]
 state.AC[row,collumn]
 state.AR[row,collumn]
-state.CR[row,collumn]
+state.C[row,collumn]
 ```
 
 Behind the scenes, we have a type called Multiline, defined as:

src/MPSKit.jl

@@ -9,6 +9,7 @@ using Base.Iterators
 using RecipesBase
 using VectorInterface
 using Accessors
+using HalfIntegers
 import TupleTools as TT
 
 using LinearAlgebra: diag, Diagonal

src/algorithms/ED.jl

@@ -14,7 +14,7 @@ function exact_diagonalization(opp::FiniteMPOHamiltonian;
 
     mpst_type = tensormaptype(spacetype(Ot), 2, 1, storagetype(Ot))
     mpsb_type = tensormaptype(spacetype(Ot), 1, 1, storagetype(Ot))
-    CLs = Vector{Union{Missing,mpsb_type}}(missing, len + 1)
+    Cs = Vector{Union{Missing,mpsb_type}}(missing, len + 1)
     ALs = Vector{Union{Missing,mpst_type}}(missing, len)
     ARs = Vector{Union{Missing,mpst_type}}(missing, len)
     ACs = Vector{Union{Missing,mpst_type}}(missing, len)
@@ -36,7 +36,7 @@ function exact_diagonalization(opp::FiniteMPOHamiltonian;
     normalize!(ACs[middle_site])
 
     #construct the largest possible finite mps of that length
-    state = FiniteMPS(ALs, ARs, ACs, CLs)
+    state = FiniteMPS(ALs, ARs, ACs, Cs)
     envs = environments(state, opp)
 
     #optimize the middle site. Because there is no truncation, this single site captures the entire possible hilbert space

src/algorithms/approximate/idmrg.jl

@@ -9,7 +9,7 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
     LoggingExtras.withlevel(; alg.verbosity) do
         @infov 2 loginit!(log, ϵ)
         for iter in 1:(alg.maxiter)
-            C_current = ψ.CR[:, 0]
+            C_current = ψ.C[:, 0]
 
             # left to right sweep
             for col in 1:size(ψ, 2), row in 1:size(ψ, 1)
@@ -18,7 +18,7 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
                 ψ.AC[row + 1, col] = h * above.AC[row, col]
                 normalize!(ψ.AC[row + 1, col])
 
-                ψ.AL[row + 1, col], ψ.CR[row + 1, col] = leftorth(ψ.AC[row + 1, col])
+                ψ.AL[row + 1, col], ψ.C[row + 1, col] = leftorth(ψ.AC[row + 1, col])
 
                 tm = TransferMatrix(above.AL[row, col], mpo[row, col], ψ.AL[row + 1, col])
                 setleftenv!(envs, row, col + 1, normalize(leftenv(envs, row, col) * tm))
@@ -31,14 +31,14 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
                 ψ.AC[row + 1, col] = h * above.AC[row, col]
                 normalize!(ψ.AC[row + 1, col])
 
-                ψ.CR[row + 1, col - 1], temp = rightorth(_transpose_tail(ψ.AC[row + 1, col]))
+                ψ.C[row + 1, col - 1], temp = rightorth(_transpose_tail(ψ.AC[row + 1, col]))
                 ψ.AR[row + 1, col] = _transpose_front(temp)
 
                 tm = TransferMatrix(above.AR[row, col], mpo[row, col], ψ.AR[row + 1, col])
                 setrightenv!(envs, row, col - 1, normalize(tm * rightenv(envs, row, col)))
             end
 
-            ϵ = norm(C_current - ψ.CR[:, 0])
+            ϵ = norm(C_current - ψ.C[:, 0])
 
             if ϵ < alg.tol
                 @infov 2 logfinish!(log, iter, ϵ)
@@ -69,7 +69,7 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
     LoggingExtras.withlevel(; alg.verbosity) do
         @infov 2 loginit!(log, ϵ)
         for iter in 1:(alg.maxiter)
-            C_current = ψ.CR[:, 0]
+            C_current = ψ.C[:, 0]
 
             # sweep from left to right
             for col in 1:size(ψ, 2), row in 1:size(ψ, 1)
@@ -81,7 +81,7 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
                 normalize!(c)
 
                 ψ.AL[row + 1, col] = al
-                ψ.CR[row + 1, col] = complex(c)
+                ψ.C[row + 1, col] = complex(c)
                 ψ.AR[row + 1, col + 1] = _transpose_front(ar)
 
                 setleftenv!(envs, row, col + 1,
@@ -105,7 +105,7 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
                 normalize!(c)
 
                 ψ.AL[row + 1, col] = al
-                ψ.CR[row + 1, col] = complex(c)
+                ψ.C[row + 1, col] = complex(c)
                 ψ.AR[row + 1, col + 1] = _transpose_front(ar)
 
                 setleftenv!(envs, row, col + 1,
@@ -120,7 +120,7 @@ function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multili
             end
 
             # update error
-            ϵ = sum(zip(C_current, ψ.CR[:, 0])) do (c1, c2)
+            ϵ = sum(zip(C_current, ψ.C[:, 0])) do (c1, c2)
                 smallest = infimum(_firstspace(c1), _firstspace(c2))
                 e1 = isometry(_firstspace(c1), smallest)
                 e2 = isometry(_firstspace(c2), smallest)

src/algorithms/approximate/vomps.jl

@@ -38,7 +38,7 @@ function approximate(ψ::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:Multilin
             end
 
             alg_gauge = updatetol(alg.alg_gauge, iter, ϵ)
-            ψ = MultilineMPS(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
+            ψ = MultilineMPS(temp_ACs, ψ.C[:, end]; alg_gauge.tol, alg_gauge.maxiter)
 
             alg_environments = updatetol(alg.alg_environments, iter, ϵ)
             recalculate!(envs, ψ; alg_environments.tol)

src/algorithms/changebonds/changebonds.jl

@@ -26,13 +26,13 @@ function _expand!(ψ::InfiniteMPS, AL′::PeriodicVector, AR′::PeriodicVector)
 
         # update C: add vectors, make room for new vectors:
         # C -> [C 0; 0 expansion]
-        l = zerovector!(similar(ψ.CR[i], codomain(ψ.CR[i]) ← _firstspace(AR′[i + 1])))
-        ψ.CR[i] = catdomain(ψ.CR[i], l)
-        r = zerovector!(similar(ψ.CR[i], _lastspace(AL′[i])' ← domain(ψ.CR[i])))
-        ψ.CR[i] = catcodomain(ψ.CR[i], r)
+        l = zerovector!(similar(ψ.C[i], codomain(ψ.C[i]) ← _firstspace(AR′[i + 1])))
+        ψ.C[i] = catdomain(ψ.C[i], l)
+        r = zerovector!(similar(ψ.C[i], _lastspace(AL′[i])' ← domain(ψ.C[i])))
+        ψ.C[i] = catcodomain(ψ.C[i], r)
 
         # update AC: recalculate
-        ψ.AC[i] = ψ.AL[i] * ψ.CR[i]
+        ψ.AC[i] = ψ.AL[i] * ψ.C[i]
     end
     return normalize!(ψ)
 end

src/algorithms/changebonds/svdcut.jl

@@ -15,7 +15,7 @@ function changebonds(ψ::AbstractFiniteMPS, alg::SvdCut; kwargs...)
 end
 function changebonds!(ψ::AbstractFiniteMPS, alg::SvdCut; normalize::Bool=true)
     for i in (length(ψ) - 1):-1:1
-        U, S, V, = tsvd(ψ.CR[i]; trunc=alg.trscheme, alg=TensorKit.SVD())
+        U, S, V, = tsvd(ψ.C[i]; trunc=alg.trscheme, alg=TensorKit.SVD())
         AL′ = ψ.AL[i] * U
         ψ.AC[i] = (AL′, complex(S))
         AR′ = _transpose_front(V * _transpose_tail(ψ.AR[i + 1]))
@@ -76,10 +76,10 @@ function changebonds(ψ::MultilineMPS, alg::SvdCut)
 end
 function changebonds(ψ::InfiniteMPS, alg::SvdCut)
     copied = complex.(ψ.AL)
-    ncr = ψ.CR[1]
+    ncr = ψ.C[1]
 
     for i in 1:length(ψ)
-        U, ncr, = tsvd(ψ.CR[i]; trunc=alg.trscheme, alg=TensorKit.SVD())
+        U, ncr, = tsvd(ψ.C[i]; trunc=alg.trscheme, alg=TensorKit.SVD())
         copied[i] = copied[i] * U
         copied[i + 1] = _transpose_front(U' * _transpose_tail(copied[i + 1]))
     end

src/algorithms/changebonds/vumpssvd.jl

@@ -35,7 +35,7 @@ function changebonds_1(state::InfiniteMPS, H, alg::VUMPSSvdCut,
                                       SvdCut(; trscheme=truncspace(infimum(D1, D2))), nenvs)
     end
 
-    collapsed = InfiniteMPS([nstate.AL[1]], nstate.CR[1]; tol=alg.tol_gauge)
+    collapsed = InfiniteMPS([nstate.AL[1]], nstate.C[1]; tol=alg.tol_gauge)
 
     return collapsed, envs
 end
@@ -51,7 +51,7 @@ function changebonds_n(state::InfiniteMPS, H, alg::VUMPSSvdCut, envs=environment
         nAC2 = vecs[1]
 
         h_c = ∂∂C(loc + 1, state, H, envs)
-        (vals, vecs, _) = eigsolve(h_c, state.CR[loc + 1], 1, :SR; tol=alg.tol_eigenval,
+        (vals, vecs, _) = eigsolve(h_c, state.C[loc + 1], 1, :SR; tol=alg.tol_eigenval,
                                    ishermitian=false)
         nC2 = vecs[1]