Welcome Dhiman, and sorry for not answering earlier.

You might want to take a look at the

tenpy.models.haldane.FermionicHaldaneModel and the

tenpy.models.haldane.BosonicHaldaneModel.

Both are based on the Hamiltonian from the paper

arXiv:1407.6985 discussing the fermionic model.

As far as I see from a quick glimpse, Equ. (2) of

arXiv:1603.04827 should be equivalent to the

tenpy.models.haldane.BosonicHaldaneModel with hard-core bosons (

`N_max=1`

).

Your way (i) and (ii) are different, and neither is correct for an arbitrary lattice. However, way (i) should be correct for your specific case of the Honeycomb lattice, where u1 and u2 of the next nearest neighbors are always equal.

The correct way to get the hermitian conjugate is mentioned in the the "Note" box of point 6

here. In your case, it would be

Code: Select all

```
for u1, u2, dx in self.lat.next_nearest_neighbors:
self.add_coupling(1j*D,u1, 'Bd', u2, 'B', dx)
self.add_coupling(np.conj(1j*D),u2, 'Bd', u1, 'B', dx) # h.c.
```

DHIMAN002 wrote: ↑06 Sep 2019, 04:52

I have created the nearest neighbor bonds and next-nearest neighbor bonds as in the following way in a "Lattice"-class,

Code: Select all

```
NN = [(0, 1, np.array([0, 0])), (0, 1, beta1), (0, 1, -beta3)]
nNN=[(0,0,beta1),(0,0,beta2),(0,0,beta3),
(1,1,-beta1),(1,1,-beta2),(1,1,-beta3)]
```

How did you define

`beta1, beta2, beta3`

? For the

`(next_)nearest_neighbors`

, they should be specified in terms of the unit vectors of the lattice, i.e. have integer entries! (You can e.g. choose

`beta1`

and

`beta2`

as unit vectors of the lattice, then they would be:

Code: Select all

```
beta1 = [1, 0]
beta2 = [0, 1]
beta3 = [-1, -1]
```

DHIMAN002 wrote: ↑07 Sep 2019, 17:16

I investigated more and found that the fluctuation of energy and entropy values after 10 sweeps(I fixed it) is changing for a certain parameter region of complex hopping amplitude above a critical value. But the code still works for complex hopping in parameter region less than a critical value, so it should not be the problem of the code. What I know about the ground state above critical value is that,

(i) The ground state is two-fold degenerate.

(ii) The ground state might not be described simply by using the two unit cells in a stripe like geometry of zigzag honeycomb lattice.

It must be one of the two above reasons that the ground state does not converge and fluctuate. But, the presence of degeneracy may not be the reason, because the DMRG should converge to minimum entangled state. The fact that ground state have to be described by more than one unit cell might be the reason. Secondly, may be chi_max need to be more for this states to capture the ground state.

So, for now I want suggestions, what is the reason behind the fluctuation of energy and entropy after 10 sweeps and how to avoid this fluctuation?

I don't know much about the physics of this specific model.

First of all, to be fair, let me mention that we are aware that there are sometimes convergence problems with iDMRG, and we are not sure what is the reason ourselves and trying to fix it for quite some time by now. In fact, the rewriting of DMRG in

Issue #39 and

Issue #85 by

@Leon was motivated by that as well; I'm not sure what his latest results on this issue are.

As you said, (i) should usually not be a problem; at least if the state is build up by gradually increasing the bond dimensions e.g. with the

`chi_list`

parameter of DMRG.

If (ii) is actually true, the problem is

*physical*, and I would expect that iDMRG with the simple/wrong unit cell has problems to generate the correct state. You can try to see what DMRG on a large finite system does, and whether it builds some larger unit cells; it behaves a little bit better in that respect. Alternatively, you can simply try out different geometries/length for your unit cell, which might help. Apart from physical insigth, there is no way to know the correct unit cell

*a priori*.

I hope this helps a little bit... Feel free to report further problems