Hamiltonian and Momentum Commutation

Hi everyone,

I’ve been trying to get a set of a states for a complex phi^4 field theory. I want to check the validity of the states acquired by the DMRG calculation by ensuring that they’re also eigenstates of the momentum operator of the theory. However, the ground state I acquire for the Hamiltonian is not an Eigenstate of the momentum operator. The variance of the Hamiltonian on this state is ~3 E-5, but the variance of the momentum on this state is ~15, completely unacceptable. I fear that the problem may be the way I’m defining my Hamiltonian and Momentum MPO’s, which I will include below. I define my operators on a bosonic local Hilbert space.

The Hamiltonian is
H = \int dx \; \left(\pi^* \; \pi + \nabla \phi^* \cdot \nabla \phi + m^2 |\phi|^2 + \lambda |\phi|^4 \right)

Which we put on the lattice by doubling the Hilbert space and putting the real part of the field on odd sites and the imaginary part on even sites, which gives us the following Hamiltonian on the doubled lattice,

H = \sum_{n=1}^{2N} \left( \frac{1}{2}\pi_{n}^2+\frac{1}{2}(\phi_{n+2} - \phi_{n})^2 +\frac{m^2}{2}\phi_{n}^2+ \frac{\lambda}{4} \phi_{n}^4 \right) + \sum_{n=1}^{N} \left( 2 \frac{\lambda}{4} \phi_{2n-1}^2 \phi_{2n}^2 \right)

The momentum operator is, using the same doubling prescription:

P = -\frac{1}{4} \sum_{n=1}^{2N} \pi_n (\phi_{n+2}-\phi_n) + h.c.

I write these MPO’s as
H:

#Define Hamiltonian: first field lives on odd sites, field 2 on even sites, interact on both
#"phi2" is the field operator squared, not to be confused with field 2. Similarly for "cpi2"
op1= OpSum()

#free terms

#bulk terms
for l in 1:2(N-1)
    op1 += (-1),"phi",l,"phi",(l+2)
    op1 += (1/2)*(1+m2), "phi2",l
    op1 += (1/2), "phi2",(l+2)
    op1 += (1/2), "cpi2",l
    op1 +=  (ld/4), "phi4",l
end

#Boundary terms
    op1 += (-1),"phi",2N-1,"phi",1
    op1 += (1/2)*(1+ m2), "phi2",2N-1
    op1 += (1/2), "phi2",1
    op1 += (1/2), "cpi2",2N-1
    op1 += (ld/4), "phi4",2N-1

    op1 += (-1),"phi",N,"phi",2
    op1 += (1/2)*(1+ m2), "phi2",2N
    op1 += (1/2), "phi2",2
    op1 += (1/2), "cpi2",2N
    op1 += (ld/4), "phi4",2N



#field coupling terms
for l in 1:N
    op1 += ((ld/2), "phi2",2l-1 , "phi2",(2l))
    op1 += ((ld/2), "phi2",2l , "phi2",(2l-1))
end


print(op1)

H = MPO(op1,sites)

and the momentum operator as

#Writing out the momentum operator as an MPO

opM= OpSum()

#well do the first term then add its h.c.

#bulk terms 
for l in 1:2(N-1)
    opM += (-1/4),"cpi",l,"phi",l+2
    opM +=-(-1/4),"cpi",l,"phi",l
    
    #need h.c. terms
    opM += (-1/4),"phi",l+2,"cpi",l
    opM +=-(-1/4),"phi",l,"cpi",l
    
end 

#boundary terms 
    opM += (-1/4),"cpi",N,"phi",2
    opM +=-(-1/4),"cpi",N,"phi",N

    opM += (-1/4),"cpi",N-1,"phi",1
    opM +=-(-1/4),"cpi",N-1,"phi",N-1

     #need h.c. terms
    opM += (-1/4),"phi",2,"cpi",N
    opM +=-(-1/4),"phi",N,"cpi",N
    
    opM += (-1/4),"phi",1,"cpi",N-1
    opM +=-(-1/4),"phi",N-1,"cpi",N-1

P= MPO(opM,sites)

where “phi” is constructed to have matrix elements \propto (a+a^\dagger), and “cpi” is the conjugate momenta \pi \propto i(a^\dagger -a). I’m certain my matrix elements of my custom operators are correct. I am working on a 10 physical site lattice (N=10), and want periodic boundary conditions, and local bosonic Hilbert space dimension of d=60.

I don’t know how to directly show the matrix elements for an MPO and multiplying the MPOs directly to get the commutator gives me a memory overflow error, so I calculated the states that are a result of the action of the operators onto a state and then calculate the imaginary part of the inner product: < \psi | [H,P] |\psi> = 2 i Im (<\psi|H)(P|\psi>). I did this with the DMRG acquired ground state and a random MPS. Should they commute this inner product should be zero. Both calculations demonstrated that these MPOs don’t commute.

Is there a glaringly obvious issue that I’m overlooking with my MPO definitions?

I know this is a long post but I’m pretty lost at this point so I thank you for your time reading this and for any input on the matter.

Best,
JM

1 Like

You can use the contract function to efficiently multiply two MPOs together. As long as each MPO has a reasonable bond dimension, then contract should run efficiently and not give you a memory overflow error. Is that what you were using to multiply them? There could be some issue for using sites (physical indices) as large as d=60 though, that we might need to optimize for.

If they do not commute, I would imagine it could be because of the truncation you are necessarily having to do of the Hilbert space (e.g. the d=60 cap), but that is just a guess. The truncation may destroy or correct some of the idealized properties of the operators that are true only for the infinite-sized Hilbert space. Does that seem like a possibility to you?

Thank you for your response. I’m still investigating the problem, but to answer your question yes I’m using contract and it runs out of memory. Actually for the same lattice size and local Hilbert space dimension of d=20 it also run out of memory. Fortunately however, the charge operator does seem to commute with H and P, so something is correct.

A fundamental issue is that MPS and MPO algorithms are design for the case of small d. In other words, they work well for lots of small indices, and not as well for a few large indices.

A nice solution to this is to use groups of indices to represent a single vector space. For example, instead of using a single index of size 8, you can use three consecutive indices of size 2. This idea turns out to be surprisingly powerful, as chaining n indices together which only has a linear cost within the tensor network gives you access to a vector space of size 2^n. The only drawback is that operators acting on the space become a little more complicated to create and work with (mainly they become MPOs instead of simpler single-site operators).

As far as I know, this idea was first introduced specifically for bosons in this paper:
https://journals.aps.org/prb/abstract/10.1103/PhysRevB.57.6376

More recently this idea has grown into a whole area called “quantics tensor trains” (which is just jargon for using MPS and splitting up large spaces into multiple indices) which is starting to have wide applications:
http://tensornetwork.org/functions/

It’s an approach you might want to consider for your application.

@jake is the total momentum operator meant to be periodic? If so then you shouldn’t expect the commutator of the MPO representations of P and H to be 0. I have encountered this when working with the momentum space representation of the Fermi-Hubbard Model.

Thank you Miles for the resources it seems very interesting I’ll starting thinking about implementing that. I found out that my operators when using a smaller Hilbert space dimension do commute. The issue is a problem with the DRMG acquired ground state, and that while its variance on H is small, it isn’t an eigenstate of P. I suspect it is from the PBC imposed when defining the operators, so I started looking into iDMRG to treat an infinite system, but I’m running into issues with it. If I cannot solve them I’ll create a new post :sweat_smile:. Thanks!

@corbett5 Yes both H and P are assuming PBC. Its interesting that you say that in the PBC case that they shouldn’t, when I construct the operators with PBC with a lower Hilbert space dimension and take the inner product of the commutator with a random MPS, or even <psi1|[H,P] |psi2> where psi 1 and 2 are random MPSs, they’re both very small ~1E-12.

For the momentum space Fermi Hubbard model I add custom momentum QN’s to the sites, so that I know for a fact the states I am using are eigenstates of the total momentum operator. However, when I construct the total momentum operator as

P = \sum_{k = 1}^N \sum_\sigma k \hat{n}_{k, \sigma}

I find that the states are not eigenstates of P. My explanation for this is as follows: The total momentum as defined above is not conserved, what is conserved is P \mod N. Furthermore, when you algebraically take the commutator of P with the Fermi Hubbard Hamiltonian you do not get zero, it is only for P \mod N that the commutator is zero.