Finite state machine MPO

How do I use this algorithm? What does that parameter do?
Post Reply
pasa
Posts: 23
Joined: 09 Mar 2020, 12:45

Finite state machine MPO

Post by pasa »

Hi everyone,

I would like to ask you: Do you know whether the ``AKLT'' Hamiltonian
\( H = \sum_j \vec{S}_j \cdot \vec{S}_{j+1} + \lambda (\vec{S}_j \cdot \vec{S}_{j+1} )^2 \)
could be written as an MPO with bond dimension less than 14? This is the bond dimension I obtained when I construct the model as follows

Code: Select all

class AKLT(SpinModel,NearestNeighborModel):
    def init_terms(self, model_params):
        SpinModel.init_terms(self, model_params)
        a = model_params.get('a', 0.)
        
        T_vec = ['Sp', 'Sm', 'Sz'] 
        Tad_vec = ['Sm', 'Sp', 'Sz']
        t_vec = [0.5, 0.5, 1.]
        #(\sum_a S_j^a*S_{j+1}^a)^n
        for k0 in range(3):
            for k1 in range(3):
                self.add_coupling(a*t_vec[k0]*t_vec[k1], 0, T_vec[k0]+' '+T_vec[k1], 0, Tad_vec[k0]+' '+Tad_vec[k1], 1) #n=2
The reason for this funny construction is that I can then easily consider higher powers of a Heisenberg interaction. The naive counting suggests that the required bond dimension has an additional \(3^n \) for every power \( (\vec{S}_j \cdot \vec{S}_{j+1} )^n \) one wants to consider. Do you know whether there is a more optimal way of making this construction such that the bond dimension is as small as possible?

Best,

Pablo

Update: there looks to be a way writing \( H = \sum_j \vec{S}_j \cdot \vec{S}_{j+1}(1 + \lambda \vec{S}_j \cdot \vec{S}_{j+1} ) \) and nesting some steps, although not clear to me yet.
User avatar
Johannes
Site Admin
Posts: 413
Joined: 21 Jul 2018, 12:52
Location: TU Munich

Re: Finite state machine MPO

Post by Johannes »

Hi Pablo,

there is a way to do it more effiently, although I only did that numerically: I created the AKLT model by just defining bond terms, and then initializing the MPO from these bond terms - there's a function in TeNPy to automatically do the SVD of the bond term to get the MPO.
Take a look at (the source of) tenpy.models.aklt.AKLTChain. I guess you can generalize it to your use-case.

Let me know if anything about it is unclear, then we can update the example accordingly!

Code: Select all

>>> M = tenpy.models.aklt.AKLTChain({'L': 10})                                           
>>> print(M.H_MPO.chi)
[2, 10, 10, 10, 10, 10, 10, 10, 10, 10, 2]
pasa
Posts: 23
Joined: 09 Mar 2020, 12:45

Re: Finite state machine MPO

Post by pasa »

Thanks a lot Johannes and sorry for my delay coming back to the forum.

Your code example is so clear that was easy generalizing it. Thanks again!

I have nevertheless two technical questions related to Tenpy.

The first one is that at the end of your function you use

Code: Select all

H_bond = H_bond.split_legs().transpose(['p0', 'p1', 'p0*', 'p1*'])
while

Code: Select all

class tenpy.models.model.NearestNeighborModel(lattice, H_bond)
expects

Code: Select all

Legs of each H_bond[i] are ['p0', 'p0*', 'p1', 'p1*']
I was wondering whether this is essential. When I compare the H_Bond Hamiltonian to that obtained by my alternative approach, they only agree if I instead use

Code: Select all

H_bond = H_bond.split_legs().transpose(['p0', 'p0*', 'p1', 'p1*']).
My second question is: What is the main difference in between the two approaches in which Tenpy gets the MPO? I guess the trick is first getting the local terms in a list instead of list of local terms of the same kind?

Thanks again.

Pablo
Post Reply