# Energy of infinite DMRG

+1 vote

Hi,

I am trying to understand how to calculate the energy for the infinite MPS.
In the idmrg.h file, you did

HL += -energy*IL;


for each sweep.

After finishing the all the sweep, the energy calculated from dmrgworker corresponds to the energy of the infinite MPS.

I wonder if the way you calculate the energy is equivalent to the recurrence formula in eq.35,36,37 of [arXiv:0804.2509][1] ? Also, does your method also apply to system with long-range interaction? In the presence of long-range interaction, the recurrence relation becomes more complicated ( [arXiv:1008.4667][2]). It is not obvious to me that the energy calculated in the idmrg.h is the same as these methods.

Thank you very much!

[1]: Infinite size density matrix renormalization group, revisited

[2]: Schur Forms of Matrix Product Operators in the Infinite Limit

+1 vote
answered by (27.6k points)
selected

Hi, good question so that line of the code which you quote is just subtracting off the energy of the system calculated for the last configuration, thinking of the last configuration as a finite-size system. (So using a "growing" picture of the idmrg algorithm.) The algorithm in the ITensor library doesn't use the more sophisticated Schur form argument you cited, although it might be equivalent to it in certain cases (not sure off hand, I'd have to check).

You could apply the code to along-range Hamiltonian by using an appropriate MPO, but you might find slow convergence given that the algorithm doesn't work with an infinite system from the outset, but grows a longer and longer finite-size system. So boundary effects might persist for a while depending on how long range the interaction is and what the correlation length of the system is.

Miles

commented by (280 points)
Thank you for your quick respond!

I still feel confused about the line HL += -energy*IL;
If we want to subtract off the energy of the last sweep, isn't it something like
HL += -IL
because in each sweep you did
for(int j = 1; j <= Nuc; ++j)
{
IL *= psi.A(j);
IL *= H.A(j);
IL *= dag(prime(psi.A(j)));
}
The energy should have been calculated by taking the overlap of psi and H. Why do we still need to multiply energy again?
commented by (27.6k points)
Yes, great question. You are right to be confused by that part (and thanks for looking at the code closely). The answer to your question is that the "IL" parts of this code are a bit of a hack: the IL tensor is initialized with a certain boundary condition that "picks out" the part of H which is just a string of identity operators only. (The reason this is a hack is that it makes certain assumptions about the internal structure of the MPO H which limits the code from working on a totally arbitrary Hamiltonian MPO. But for a correctly designed MPO the hack works perfectly.)

So even though it looks like IL contains terms from H, it is actually just "borrowing" the part of each H MPO tensor which contains an identity operator and no other part of H. The reason for doing things this way is so that IL has a compatible tensor structure with HL. I'd like to find a simpler way to do the energy subtraction (or some other appropriate treatment of the energy) in the future.
commented by (280 points)
Oh! I see!

The tricky part is in this constructor:

template <class Tensor>
idmrgRVal<Tensor>
idmrg(MPSt<Tensor>      & psi,
MPOt<Tensor> const& H,
Sweeps       const& sweeps,
DMRGObserver<Tensor> & obs,
Args         const& args)
{
auto lval = idmrgRVal<Tensor>();
lval.IL = Tensor(dag(H.A(H.N()+1)));
return idmrg(psi,H,lval,sweeps,obs,args);
}

You start with the end of the finite state machine so all the multiplication of H are just multiplication of identity matrix. By doing so, the Index of the IL are identical to HL.
This is really a smart trick! Thank you for your explanation!
commented by (27.6k points)
Thanks! Yes actually now that I look back at how IL is initialized, it might be that it does work for any Hamiltonian MPO, regardless of the convention used to construct it. But it at least definitely works for Hamiltonian MPOs following the "lower triangular" convention I usually follow.