TASEPCompact.py

From Werner KRAUTH

This page is part of my 2024 Beg Rohu Lectures on "The second Markov chain revolution" at the Summer School "Concepts and Methods of Statistical Physics" (3 - 15 June 2024).

My Lecture 3 is concerned with the Symmetric Simple Exclusion Process (SSEP) and its liftings, the TASEP (totally asymmetric simple exclusion process) (treated here) and the lifted TASEP. All these dynamical systems carry the word "Process" in their descriptions. This is because they are usually described in continuous time. We rather use a formulation in descrete time, where at each time step, a single move is attempted. In fact, each move consists in the choice of a random particle and the choice of a random direction.

Here, as mentioned, we are concerned with the TASEP. With periodic boundary conditions, we may separate the forward-and-backward moving TASEP, as discussed in Lecture 3, into two independent copies. At each time step, the TASEP samples the random particle to be moved (forward). This, as discussed, is one half of a lifting of the SSEP.

Contents 1 Python program 2 Output 3 Further Information 4 References

Python program

import math
import random
exponent = 2.0
alpha = 0.5
prefactor = 1.0
NPart = 32; NSites = 2 * NPart
NIter = int(prefactor * NPart ** exponent)
NStrob = NIter // 20
Conf = [1] * NPart + [0] * (NSites - NPart)
Text = 'Periodic TASEP, N= ' + str(NPart) + ', L= ' + str(NSites)
print(' ' * (NSites// 2 + 1 - len(Text) // 2) + Text + ' ' * (NSites// 2 + 1 - len(Text) // 2))
print('-' * (NSites + 2))
for iter in range(NIter):
    Active = random.randint (0, NSites - 1)
    while Conf[Active] != 1:
        Active = random.randint(0, NSites - 1)
    Step = 1
    NewActive = (Active + Step) % NSites
    if Conf[NewActive] == 0:
       Conf[Active], Conf[NewActive] = 0, 1
    if iter % NStrob == 0:
        PP = str()
        for k in range(NSites):
            if Conf[k] == 0: PP += ' '
            else: PP += 'X'
        print('|' + PP + '|')
print('-' * (NSites + 2))
Text = 'Total time = ' + str(prefactor) +  ' *  N ^ ' + str(exponent)
print(' ' * (NSites// 2 + 1 - len(Text) // 2) + Text + ' ' * (NSites// 2 + 1 - len(Text) // 2))

Output

. Here is output of the above Python program for the TASEP with, for simplicity, N=32, L=64. Over the entire life-time of the simulations (here N^2 single moves), only 20 configurations are shown, one roughly every 50 steps.

                   Periodic TASEP, N= 32, L= 64
------------------------------------------------------------------
|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX                                |
|XXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX X                              |
|XXXXXXXXXXXXXXXXXXXXXXXXX XXXX XX  X                            |
|XXXXXXXXXXXXXXXXXXXXXXXX XXXXX X X X                            |
|XXXXXXXXXXXXXXXXXXXXXX XXXXXX X  XX X                           |
|XXXXXXXXXXXXXXXXXXXXX XXXXX X  XXX XX                           |
|XXXXXXXXXXXXXXXXXXXXX XXX XX  XXXX X X                          |
|XXXXXXXXXXXXXXXXXXX XXXXX  X XX XX  XXX                         |
|XXXXXXXXXXXXXXX XXXXXXXXX  X XX X  XXXX                         |
|XXXXXXXXXXXXXX XXXXXXXX XX  XX   XX XXX  X                      |
|XXXXXXXXXXXXXX XXXXXXXX   XXXX    XX X X XX                     |
|XXXXXXXX XXXXXXXXXXXXX   X XXXX   XX  XX XX                     |
|XXXX XXXXXXXXXXXXXXXXX    XX XX X X  XX X X X                   |
|XX XXXXXXXXXXXXXXXXXX X   X XXX   X XX X XX   X                 |
| XXXXXXXXXXXXXXXXXX X XX   XXX X   XX  XXX   X    X             |
| XXXXXXXXXXXXXXX X XX XX X X X X  XX X XX  X X      X           |
| XXXXXXXXXXXXXX XX  X XXX X XX  X  XX XXX   X   X   X           |
| XXXXXXXXXXX XX XXX  XX XX XX X X   XXXXX    X   X   X          |
| XXXXXXXXX XXX XXXX  XX  XXXX   X  XXX  X X  XX    X  X         |
| XXXXXXXX XXXX XXXX  XX  XXX X    XX XX  XX   X   X X    X      |
| XXXXXXX XXXX XX XXX XX   XX X  X  XX X XXX   X   X  X   X      |
------------------------------------------------------------------
                    Total time = 1.0 *  N ^ 2.0

With all its limitations, the program illustrates that the N^2 steps are not sufficient to move the compact initial state and to approach the equilibrium.

Further Information

• The mixing behavior of the TASEP t_mix \sim N^(5/2) has been computed by Baik & Liu (2016) (see references). This is in our units, where one move takes place per unit time.
• The relaxation time of the TASEP is likewise t_rel \sim N^(5/2). Again this is in the MCMC units of one move per time step.
• The description of the TASEP as a lifting of the SSEP is from Kapfer et al. (2017) (see references).
• An example transition matrix for the TASEP with open boundary conditions (hard walls) can be found in Essler & Krauth (2024).
• The TASEP can be solved by Bethe ansatz, and many of its properties are known.
• As discussed at length in Lecture 3, the transition matrix of the TASEP is doubly stochastic so that, in equilibrium, every allowed configuration is equally likely.

References

• Baik, J., and Z. Liu, Z. TASEP on a Ring in Sub-relaxation Time Scale. J. Stat. Phys., 165(6): 1051–1085, 2016.
• Dhar D. An exactly solved model for interfacial growth. Phase Transitions, 9(1):51, 1987
• Essler F. H. L., Krauth W., Lifted TASEP: a Bethe ansatz integrable paradigm for non-reversible Markov chains, Phys. Rev. X 14, 041035 (2024).
• Kapfer S. C. and Krauth W., Irreversible Local Markov Chains with Rapid Convergence towards Equilibrium, Phys. Rev. Lett. 119, 240603 (2017).