MC-05 Bosons

Quantum phase transitions in the Bose-Hubbard model

As an example of the worm QMC code we will study a quantum phase transition in the Bose-Hubbard mode.

Superfluid density in the Bose Hubbard model

Preparing and running the simulation from the command line

The parameter file parm5a sets up Monte Carlo simulations of the quantum Bose Hubbard model on a square lattice with 4x4 sites for a couple of hopping parameters (t=0.01, 0.02, …, 0.1) using the worm code.

LATTICE="square lattice";
L=4;
MODEL="boson Hubbard";
NONLOCAL=0;
U    = 1.0;
mu   = 0.5;
Nmax = 2;
T = 0.1;
SWEEPS=500000;
THERMALIZATION=10000;
{ t=0.01; }
{ t=0.02; }
{ t=0.03; }
{ t=0.04; }
{ t=0.05; }
{ t=0.06; }
{ t=0.07; }
{ t=0.08; }
{ t=0.09; }
{ t=0.1; }

Using the standard sequence of commands you can run the simulation using the quantum worm code

parameter2xml parm5a
worm --Tmin 10 --write-xml parm5a.in.xml

Preparing and running the simulation using Python

To set up and run the simulation in Python we use the script tutorial5a.py. The first parts of this script imports the required modules and then prepares the input files as a list of Python dictionaries:

import pyalps
import matplotlib.pyplot as plt
import pyalps.pyplot


parms = []
for t in [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1]:
parms.append(
    { 
        'LATTICE'        : "square lattice", 
        'MODEL'          : "boson Hubbard",
        'T'              : 0.1,
        'L'              : 4 ,
        't'              : t ,
        'mu'             : 0.5,
        'U'              : 1.0 ,
        'NONLOCAL'       : 0 ,
        'Nmax'           : 2 ,
        'THERMALIZATION' : 10000,
        'SWEEPS'         : 500000
    }
)

To run this, launch your python interpreter using the convenience scripts alpspython or vispython. We next convert this into a job file in XML format and run the worm simulation:

input_file = pyalps.writeInputFiles('parm5a',parms)
res = pyalps.runApplication('worm',input_file,Tmin=5)

We now have the same output files as in the command line version.

Evaluating the simulation and preparing plots using Python

To load the results and prepare plots we load the results from the output files and collect the magntization density as a function of magnetic field from all output files starting with parm5a. The script is again in tutorial5a.py

data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm5a'),'Stiffness')
magnetization = pyalps.collectXY(data,x='h',y='Stiffness')

To make plots we call the pyalps.plot.plot and then set some nice labels, a title, and a range of y-values:

plt.figure()
pyalps.plot.plot(rhos)
plt.xlabel('Hopping $t/U$')
plt.ylabel('Superfluid density $\\rho _s$')
plt.show()

Setting up and running the simulation in Vistrails

To run the simulation in Vistrails open the file mc-05-bosons.vt and look at the workflow labeled “L=4”. Click on “Execute” to prepare the input file, run the simulation and create the output figure.

Questions

What is the signature of the phase transition?

The transition from the Mott insulator to the superfluid

We next want to pin down the location of the phase transition more accurately. For this we simulate a two-dimensional square lattice for various system sizes and look for a crossing of the quantity $\rho_s L$.

Preparing and running the simulation from the command line

In the parameter file parm5b we focus on the region around the critical point for three system sizes L=4,6, and 8:

LATTICE="square lattice";
MODEL="boson Hubbard";
NONLOCAL=0;
U    = 1.0;
mu   = 0.5;
Nmax = 2;
T = 0.05;
SWEEPS=600000;
THERMALIZATION=150000;
{ L=4; t=0.045; }
{ L=4; t=0.05; }
{ L=4; t=0.0525; }
{ L=4; t=0.055; }
{ L=4; t=0.0575; }
{ L=4; t=0.06; }
{ L=4; t=0.065; }
{ L=6; t=0.045; }
{ L=6; t=0.05; }
{ L=6; t=0.0525; }
{ L=6; t=0.055; }
{ L=6; t=0.0575; }
{ L=6; t=0.06; }
{ L=6; t=0.065; }
{ L=8; t=0.045; }
{ L=8; t=0.05; }
{ L=8; t=0.0525; }
{ L=8; t=0.055; }
{ L=8; t=0.0575; }
{ L=8; t=0.06; }
{ L=8; t=0.065; }

The simulation can be run as above and the evaluated using Python

Preparing, running and evaluating the simulation using Python

The Python script tutorial5b.py similarly prepares the input file and then runs the simulation. we skip this part and instead focus on the evaluation part. We first load the superfluid density (stiffness) into three different data sets, one for each system size L:

data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm5b'),'Stiffness')
rhos = pyalps.collectXY(data,x='t',y='Stiffness',foreach=['L'])

Next we multiply each data set by the size L:

for s in rhos:
s.y = s.y * float(s.props['L'])

And finally we make a plot in the usual way:

plt.figure()
pyalps.pyplot.plot(rhos)
plt.xlabel('Hopping $t/U$')
plt.ylabel('$\\rho _sL$')
plt.legend()
plt.title('Scaling plot for Bose-Hubbard model')
plt.show()

Note the legend and labels that are nicely set up.

Setting up and running the simulation in Vistrails

To run the simulation in Vistrails open the file mc-05-bosons.vt and look at the workflow labeled “scaling plot”. Click on “Execute” to prepare the input file, run the simulation and create the output figure:

(picture TBA)

Questions

How can you determine the location of the quantum phase transition in the thermodynamic limit?
Tip: Multiply your results for the superfluid stiffness by the respective linear system size L.
Compare your result to the exact result (t/U)c = 0.05974…
Why does the Monte Carlo simulation overestimate the critical point of the transition?

Contributors

Simon Trebst
Synge Todo
Matthias Troyer

MC-04 Measurements MC-06 QWL