# Numerical stability in using nmultMPO() function

+1 vote

Dear all.

I was tried to calculate $LDL = L^{\dag} L$ using function $LDL = nmultMPO(L,prime(L^{\dag}))$, where MPO $L$ is non-Hermite but $LDL$ is. However, the norm of the first site or the elements in $LDL$ are very large and increased with the site number. Does this affect the numerical stability when I apply operator $LDL$ to perform DMRG? and how to avoid this in ITensor?

Thanks,
Meng

//============================================================
Maximum bond dimension of LDL is 10
HDH =

{norm=209646.02 (Dense Cplx)}
(1,1,1) -51924.903185+100969.181856i
(2,1,1) 94968.639912-0.000153i
(3,1,1) 0.222645-1.671171i
(4,1,1) 0.000091-0.000000i
(1,2,1) 10.799380-20.999645i
(2,2,1) -0.000000+0.172233i
(3,2,1) 1070.507353-8035.221267i
(4,2,1) -0.000000-50.163654i
(1,1,2) 10.799380-20.999645i
(2,1,2) -0.000000-0.172233i
(3,1,2) 1070.507353-8035.221267i
(4,1,2) 0.000000+50.163654i
(1,2,2) -51924.903185+100969.181856i
(2,2,2) -94968.639912+0.000153i
(3,2,2) 0.222645-1.671171i
(4,2,2) -0.000091-0.000000i

Hi, it's a good question but the answer may not be obvious.

The reason for the behavior you are seeing is that an algorithm like nmultMPO handles MPO's by treating them as MPS with extra site indices (two site indices on each "MPS" tensor). Then it uses MPS "gauge" transformations – bringing an MPS into left or right orthogonal or canonical form – to make the algorithm work better (either more accurate, or efficient, or both).

But the downside of treating an MPO this way can be that some MPO's have a very large norm when viewed as an MPS and this is just a fundamental fact. The key example would be the identity operator which, if mapped to an MPS, has a norm that is exponentially large in the number of sites or length of the system.

So the only ways around this issue I can think of are either pre- or post-multiplying your MPO by some factor to bring the norm closer to a reasonable value, or else investigating algorithms for multiplying MPOs that do not rely on mapping them to MPS or especially orthogonalizing them using MPS gauging techniques.

I should mention that a large class of MPOs do not suffer from this problem and "behave" quite well as MPS, basically MPOs that are far from the identity, so it really depends on the input and situation.

Finally, you may just want to try these things:
* creating an exact numerical check that your MPO multiplication succeeded (this sort of thing can be done efficiently and numerically exactly, i.e. computing the norm of the distance between your output MPO and the product of the input MPOs)
* just inputting your MPO to DMRG or some other algorithm to see if it works ok. It's hard to say in advance just from looking at it whether the DMRG code will be successful for some MPO or another – one just has to try.

A key thing here is that if this is happening, to study your results on smaller system sizes and just gradually go to larger sizes and keep confirming that the results are reasonable.

Best,
Miles