PHYS3934 Statistical Mechanics (Adv)

Computer Lab 3:
In this computational lab we will cover:
- PART 1: Universality and Critical Exponents

We will not cover

- PART 2: The Renormalization Group ( )
but it is fun and we leave the material in the slides as a (FYI) in
case you are interested to learn more about this framework
 PART 1: Universality and Critical Exponents
• Re-download this GitHub repository (We made some minor changes to the [Link] function )
• We'll use the [Link] function to get statistics on cluster sizes
• Second-order phase transitions are characterized by additional distinguishing features near their critical point:
• Power-law decay of correlations
• Power-law statistics of macroscopic thermodynamic quantities.
• Universality: (amazingly) these features depend on basic properties of the system (e.g., its dimension, the range of interactions) but
not on the microscopic details of the underlying Hamiltonian.
• The power-law scaling of thermodynamic quantities can be characterized by critical exponents, in terms of a dimensionless
temperature, :

• Heat capacity, .

• Magnetization, ;
• Magnetic susceptibility, ,
• Correlation length, ,
 ❓
Cluster-size statistics in the Ising Model
❓ !
• Let's test the power-law statistics of the Ising
model at
• The distribution of cluster sizes.
• Define a cluster as a set of spins that are
connected through pairs of aligned neighbors
• Clusters of an example grid shown.
• The ClusterSizeStats function labels all clusters
(shown using coloring) and returns their sizes.
• What do you think the distribution of cluster
sizes will look like at low and high ?
• Note: At , if powerlaw, , then we
have a straight line on loglog:
 Cluster-size statistics in the Ising Model
❓
• Task 1. Simulate a typical equilibrium state • Task 2. [Doesn't work in Python] Incorporate
of the 2D Ising Model at: (i) low ; (ii) ; the ClusterSizeStats function into
and (iii) high . SampleGrid, replacing IsingPlot with code
shown below.
• Recall: Wolff sampling is efficient near
. • Watch the cluster-size distribution
change as the sampler settles down to
• Use as big a grid as you can
the equilibrium distribution.
( ) Why is bigger better?
• Use intuition from Task 1 to interpret the
• Zoom in/out! Are the statistics self-similar? cluster distributions.
(is the structure similar at different
scales?) % Matlab: (Replace IsingPlot in SampleGrid with):
if mod(t,everyT)==0
ClusterSizeStats(grid);
• Use ClusterSizeStats to investigate how drawnow()
the cluster-size distribution depends on . end
The critical point ('between order and disorder')
 The critical point ('between
order and disorder')
!
• A sight you will never forget!!
• Straight line on logarithmic axes
consistent with the power-law
distribution, .

• Zoom in/out! Does the cluster structure

look self-similar across different scales?
• (consistent with rescaling space,
for some scaling factor, )?
• Another name for this is a scale-free
distribution
 !
PART 2: (FYI) The
Renormalization Group ( )
!
• A general framework for understanding critical
phenomena
• (FYI: not a group, and unrelated to renormalized
fields ).
• The basic idea is to reduce the enormous number
of degrees of freedom in a typical many-body
system to a smaller number of variables that leave
the essential physics that we're interested in
intact.
• In the Ising model we will think of a spatial coarse-
graining:
• Does smearing out the microscopic details of
the model leave the physics intact?
The Block-Spin Transformation

• Let's play with an example of a

renormalization group transformation: a
block-spin transformation:

1. Start with a lattice

2. Divide (coarse-grain) into non-

overlapping blocks.

3. For each block, replace the spins in

that block by a single spin whose
state is given by the majority vote of
the spins in the block.
The Block-Spin Transformation
❓ # "
• We can think about the transformation as mapping
a state at to a new state at new state at , as
.
• So continued applications the block-spin
transformation define a flow through .

• What would it mean about the physics at a fixed-

point of the flow ( )

• The physics is invariant to rescaling in space

• This idea of flows through a given transformation is

key to understanding universality
• the common macroscopic properties of systems
with different microscopic physics (esp. near
critical points).
Spoiler: Renormalization Group
Flow
!
• See if you can numerically deduce a flow like
this:

• The critical point of the Ising model, , is a

fixed point of the block-spin renormalization
group flow.
• The statistics of the Ising model are scale
invariant at the critical point.

• And not just the Ising Model!

• Universality: We can unite the macroscopic
behavior of systems with different
microscopic details via their renormalization
group flow.
 Your mission
• Q1 Write a function, CoarseGrain(), that • Q3 Run a Metropolis sampler on a grid at
implements a block-spin transformation of a given temperature until it settles on a typical
a given input grid. equilibrium state.
• Complete the missing parts (labeled ...) from • What do you notice about the block
the template on the next slide. transformation?
• Q2 Plot the result on a sample grid (e.g., a random • You should find that the coarse-grained
) and check that it works. ( ) grid resembles a typical state of the
system at a different temperature.
• Edit SampleGrid so that you can watch both the
full-size and coarse-grained version as you run • Repeat for different temperatures. At what
a sampling algorithm. temperatures does the transformed grid look
like a lower- or higher-temperature version of
the original?
• Reason about the fixed points of repeated
applications of the block-spin transformation?
(the renormalization group flow).
 Matlab version Python version
function newGrid = CoarseGrain(grid) import numpy as np
% 3 x 3 majority-vote coarse-graining of an input grid
%------------------------------------------------------------- def coarse_grain(grid):
# 3 x 3 majority-vote coarse-graining of an input grid
% Check square grid #------------------------------------------------------------
assert(size(grid,1)==size(grid,2))
N = size(grid,1); # Check square grid
% Check 3N x 3N grid for some integer N assert [Link][0] == [Link][1]
assert(rem(N,3)==0) N = [Link][0]

newGrid = zeros(N/3,N/3); # Check 3N x 3N grid for some integer N

assert N % 3 == 0
for i = 1:N/3
ii = (i-1)*3+1; new_grid = [Link]((N // 3, N // 3), dtype=int)
for j = 1:N/3
jj = (j-1)*3+1; for i in range(N // 3):
ii = i * 3
% Get the local 3x3 grid: for j in range(N // 3):
localGrid = ...; jj = j * 3

% Determine majority spin: # Get the local 3x3 grid:

newGrid(i,j) = ...; local_grid = ...
end
end # Determine majority spin (mode of the 3x3 block):
new_grid[i,j] = ...
end
return new_grid
 We done here
" ! #
• Thank you all for your engagement with this course—hope you
enjoyed it

• Please fill the USS survey and share feedback with your
friendly staff-student liaison