Wrong correlation length

[nattanti]

I have an InfiniteMPS with bond dimension 2 which comes from solving the Hamiltonian -X with VUMPS. The correlation_length function does not return a value close to zero. Instead I get values of order 1-10 depending on the run.

I checked the entanglement spectrum and the 2nd largest eigenvalue is of order 1e-17, which looks correct. However the function transfer_spectrum which is used to calculate the correlation length gives varying values of the 2nd largest eigenvalue depending on the run ranging from 0.9 to 10^-3 (in absolute value)

init_state=InfiniteMPS([ℂ^2], [ℂ^2])
chain = PeriodicArray([ℂ^2])
operators = [(1)=> - X]
H = InfiniteMPOHamiltonian(chain,operators...)
groundstate, environment, δ = find_groundstate(init_state, H, VUMPS(; verbosity=0,maxiter=400,tol=1e-14))

@show spectrum = abs.(transfer_spectrum(groundstate; num_vals=20))
@show entanglement_spectrum(groundstate, 1) 
@show correlation_length(groundstate)

[lkdvos]

Hi @nattanti, thanks for reaching out!

The problem here is mostly that the groundstate of this Hamiltonian is actually a cat state, (all + or all -), which is a bit pathological to deal with.
In particular, that would be a non-injective state.
VUMPS and our environments don't handle non-injective states very well because of various technical reasons, so typically what happens is either the cat state collapses into one of the groundstates, or the algorithm doesnt converge.
Here, because of the discrete symmetry it is very likely that the algorithm ends up selecting one of the groundstates, effectively becoming a product state.
This is visible in the entanglement spectrum as well, where the second largest value is 1e-17, which is effectively 0 (up to floating point errors). So, in some sense you can think of the MPS that is obtained by VUMPS as a product state + a very small perturbation that is simply the numerical noise from the machine precision. Note that this noise is completely random, in the sense that it will always be of the same order, but depending on various things like initialization and number of iterations etc it fluctuates around a bit.

The way that we are computing the correlation length is based on the gap of the transfer matrix, but that doesn't work for a product state since then the transfer matrix is actually a 1x1 matrix, so there is no second eigenvalue. Here there are additional elements in that transfer matrix that are based purely on these noise values, therefore giving you results that aren't trustworthy at all.

If you go slightly away from this pathological point, for example by adding a small ZZ term into the hamiltonian, these effects should disappear and the correlation lengths should be trustworthy again.

Hope this helps!

[nattanti]

Hi @lkdvos, thank you for the prompt reply!

Sorry, perhaps there was some ambiguity in my question. My Hamiltonian is -X (not -XX) so it should converge to only the product state all +. Indeed, the entanglement spectrum has second largest eigenvalue 0 up to floating points, but this is not the case for the transfer spectrum. Here are three runs of the code above which return extremely different values for the correlation length

spectrum = abs.(transfer_spectrum(groundstate; num_vals = 20)) = [1.0000000000000004, 0.0012080290564980658, 0.0012080290564979996, 9.250882065883763e-6]
entanglement_spectrum(groundstate, 1) = TensorKit.SortedVectorDict(Trivial() => [1.0, 1.4668112851940975e-17])
correlation_length(groundstate) = 0.14883687421602312

spectrum = abs.(transfer_spectrum(groundstate; num_vals = 20)) = [1.000000000000001, 0.979662318977359, 0.9796623189773583, 0.959860426479216]
entanglement_spectrum(groundstate, 1) = TensorKit.SortedVectorDict(Trivial() => [1.0, 9.808530391372463e-14])
correlation_length(groundstate) = 48.66810207430536

spectrum = abs.(transfer_spectrum(groundstate; num_vals = 20)) = [0.9999999999998478, 0.9999999999988528, 0.9999999999988526]
entanglement_spectrum(groundstate, 1) = TensorKit.SortedVectorDict(Trivial() => [1.0, 9.736162073868486e-10])
correlation_length(groundstate) = 8.7143955637924e11

As you can see, the second largest eigenvalue of the transfer spectrum is not zero up to floating points, resulting in a non-zero correlation_length that can be ridiculously large in some runs

[lkdvos]

I see, you are right. The same explanation still holds for the product state though, the additional values in the transfer matrix spectrum don't really have too much meaning, since they are effectively completely blown up numerical noise.

As a way to see this, note that the transfer matrix we use is AL * adjoint(AL). Comparing this to the center-gauged MPS tensor, we see that AL * C = AC is a factorization, where AC has to be an isometry and C contains the entanglement spectrum. As a result of our product state/entanglement spectrum C completely kills the second state in our virtual space. Therefore, solving this equation is very ill-conditioned, since C[2,2] is basically zero but AL still has to be an isometry, so we are effectively getting to a 1/eps() = 1/0 kind of problem.
All of this to say that this part of the AL tensor is really just very ill-conditioned, since it is getting killed by that subspace of the C tensor.

julia> groundstate.AL[1]
TensorMap((ℂ^2 ⊗ ℂ^2) ← ℂ^2):
[:, :, 1] =
  0.4565494052666278 + 0.20575297724627645im    0.7083150811667468 + 0.4222331817270602im
 0.10357399710748659 + 0.023035121199076226im  0.23442413774684637 + 0.05499429880941927im

[:, :, 2] =
 0.4793067762546858 + 0.6457083142212255im   -0.22862135861740754 - 0.40594144633516105im
  0.264390577926531 + 0.14600294462914695im  -0.18501876113037627 - 0.10401165418473961im


julia> groundstate.AC[1]
TensorMap((ℂ^2 ⊗ ℂ^2) ← ℂ^2):
[:, :, 1] =
 0.6020976004906856 + 0.3246232531471651im    0.6020976004906855 + 0.3246232531471654im
 0.1745897882063269 + 0.04020732338244064im  0.17458978820632687 + 0.04020732338244067im

[:, :, 2] =
 2.247004244338124e-16 + 3.0270995415440353e-16im  -1.0717836438154068e-16 - 1.9030654229331818e-16im
 1.239470794479753e-16 + 6.844660925328406e-17im    -8.673733861864479e-17 - 4.8760968964384476e-17im

The final result is that we are then computing the spectrum of a transfer matrix where a large part of that matrix is simply determined by 1/+-eps, which gives large fluctuations that have no physical meaning.

[lkdvos]

I will close this issue, feel free to re-open or add new issues and questions if things are not clear.