Exercici de física estadística: Model d’Ising N-Dimensional

Adam Teixidó Bonfill

June 19, 2017

Abstract
S’intenta simular el model d’Ising en dimensió arbitrària mitjançant un model amb ordi-
nador, ja que el model d’Ising no és soluble analíticament en qualsevol dimensió, o almenys la
solució no ha estat trobada. A més, la creació d’aquesta simulació és més senzilla que realitzar
el desenvolupament analític en 2 dimensions.
El model presenta una evolució ’temporal’ dels spins, de manera que és possible analitzar-
lo. També s’analitza el comportament del paràmetre d’ordre, la magnetització, per a observar
les transicions de fase i les temperatures i exponents crítics. Després es compararà amb els
resultats obtinguts analíticament.
Els resultats concorden amb l’esperat, encara que no ha estat possible calcular els exponents
crítics per falta de temps.

1 Introducció
El sistema que considerem és una graella d’spins ordenats en l’espai en N dimensions, de la forma
més senzilla possible, linealment en 1D, rectangularment en 2D, cúbicament en 3D, i així succes-
sivament. De manera que poden ser indexats usant un vector d’N coordenades enteres. A més,
considerarem que té condicions de contorn toroïdals.
Com que no tenim coneixement de quina és la dinàmica dels spins quan es troben agrupats,
usarem l’únic que coneixem, que és la seva energia en funció de la configuració en que es troba el
sistema.
Utilitzant les mateixes definicions que hem usat a classe, l’energia del sistema és:
X X
E=− Jsi sj − Hsi
hi ji i

Per una banda, podríem calcular la funció de partició canònica del sistema sencer i les probabil-
itats de tenir cada possible estat (estat = combinació d’spins). Després, podríem calcular el valor
mig dels spins hsi i, que és una mesura directa de la magnetització. Tot i així, hauríem de trobar
una manera de simplificar els sumatoris sobre tots els estats, perquè tenim un nombre massa gran
D
2L d’estats possibles, on L és el nombre de caselles que s’allarga la graella en cada dimensió, i D
és la dimensió.
Però enlloc d’això usarem l’estratègia de dividir el problema en parts més senzilles. Consider-
arem el cas del subsistema format per un sol spin, mentre mantenim l’entorn fix. I mirarem les
probabilitats que té de canviar d’estat o mantenir-se igual, donat l’entorn actual.
X1
Ei (si ) = − Jsi sj − Hsi
2
hi ji

L’anterior és l’energia ’potencial’ de l’spin en la posició i. Hem de dividir el terme de les parelles
(hi ji) entre 2 perquè en girar-se, l’spin i guanya o perd una certa quantitat d’energia J/2, però
la seva parella també guanya o perd la mateixa quantitat, duplicant el canvi d’energia total en el
sistema, que passa a ser J.
Per a escriure amb més claredat el model, podem considerar un ’camp magnètic efectiu’ (Vi ),
que serà independent del valor de l’spin si :
Ei X1
Vi = = Jsj + H (1)
−si 2
hi ji

1
 Ara, podrem aplicar la col·lectivitat canònica al nostre spin i veure quina probabilitat tenim
que el nostre spin sigui ’up’ o ’down’ (donat l’actual entorn).

p(si = +1) ∝ e−βEi = eβVi (2)

p(si = −1) ∝ e−βEi = e−βVi (3)

2 Descripció del model utilitzat

Com que podem usar coordenades per a localitzar els spins, la base del model consisteix en una
matriu D-dimensional, que s’estén una longitud L en cada dimensió. I en cada una de les seves
caselles pot prendre valor +1 o -1. La simulació en sí consisteix en:
1. Inicialitzar la matriu amb unes condicions inicials arbitràries.
2. Considerar un dels spins de la matriu aleatòriament, i calcular les probabilitats de que estigui
en estat ’up’ o ’down’, usant les fórmules obtingudes al final de la introducció: 1, 2, 3.

3. "Llençar una moneda" no equilibrada, amb una probabilitat pup , i una altra pdown . El que
surti dictarà quin valor haurem de donar (+1 o -1) a l’spin.
4. Apliquem repetidament els passos 2 i 3, de manera que els spins del sistema aniran evolucio-
nant.

Podem considerar que aquesta és una simulació del comportament del sistema al llarg del
temps. Per a tenir una bona escala de temps, independent del nombre d’spins (LD ) del sistema,
considerarem que LD repeticions és un ’segon’ o unitat de temps. L’escollim perquè de mitjana en
aquest temps cada spin del sistema haurà tingut una oportunitat de canviar.

3 Anàlisi del model

3.1 Metodologia de l’estudi
Considerarem la següent taula de valors per a realitzar les simulacions:

L 15 (10 per 4D)

D 1, 2, 3, 4
J 1
H 0, 0.02, 0.08, 0.2, 0.8
T 0.1 a 4 en intervals de 0.1

Table 1: Taula que dóna els paràmetres dels quals es farà simulació

T és un nou paràmetre, és indicador de la temperatura, i la definim com 1/β. Cada simulació

estarà parametritzada pels seus valors de T , H i D, ja que L i J són fixos. Les simulacions duraran
200 unitats de temps (100 per a 4 dimensions), per assegurar-nos que s’arriba a l’estat estacionari,
i que les mitjanes que en traurem són acurades.
El valor que guardarem en cada simulació és la mitjana de l’spin hsi it al llarg de l’espai, és
a dir de tota la matriu, i la guardarem cada dècima d’unitat de temps (usant t com a índex).
Així podrem veure l’evolució temporal del sistema representant hsi it respecte el temps. (Exemple:
Figura 1)
Després en farem també la mitjana al llarg del temps, i obtindrem un punt hsi i(H, T, D) per
cada simulació, que representarem en un gràfic de valor mitjà de l’spin (o magnetització) respecte
temperatura. En el gràfic també representarem diferents valors de camp magnètic extern H,
obtenint així diverses corbes que ens permetran comparar comportaments. (Exemple: Figura 4)
Ens falta tractar la qüestió de quines condicions inicials escollirem en cada simulació. El que
farem serà començar amb tots els spins amunt, a un camp magnètic fix H, i a la temperatura més
alta, T = 4.0. Simularem les corresponents unitats de temps indicades en la taula inicial (200 o
100), i després disminuirem la temperatura en 0.1, farem la següent simulació, i repetirem el procés
fins arribar a T = 0.1. En acabar qualsevol de les simulacions, la graella d’spins resultant seran

2
les condicions inicials de la següent simulació. D’aquesta manera, en els gràfics que obtinguem
finalment de magnetització-temperatura, serà com si el nostre sistema vingués de la dreta, de tem-
peratures altes, i es desplacés cap a l’esquerra gradualment a mesura que li disminuïm externament
la temperatura.

3.2 Resultats obtinguts

En primer lloc es presenta com el programa simula l’evolució d’un sistema d’spins al llarg del
temps.

Figure 1: Evolució temporal de l’spin en una simulació en 3 dimensions, amb H = 0, i molt a

prop de la temperatura crítica Tc ≈ 2.4. Observem com les fluctuacions d’spin mitjà es fan molt
grosses, i com sembla que tenir un spin mitjà positiu (≈ 0.05), negatiu (≈ −0.05) o zero, tingui
una certa estabilitat. Sembla que hi hagi varis estats meta-estables entre els que el sistema va
oscil·lant.

En les gràfiques que vénen després s’observen els comportaments mitjans de totes les simulacions
tal com hem especificat prèviament. Resultats que també obtindríem, però de forma exacta,
calculant l’esperança de la magnetització amb el model d’Ising. Així que podrem comparar la seva
semblança.
Per a cada dimensió hem fet un gràfic diferent, per més claredat.

3
Figure 2: Resultat de les simulacions 1-D

Figure 3: Resultat de les simulacions 2-D

4
 Figure 4: Resultat de les simulacions 3-D

Figure 5: Resultat de les simulacions 4-D.

3.3 Comentaris sobre els resultats

Observem com major és el camp magnètic més s’allunyen les corbes de magnetització del 0.

5
 Podem observar molt clarament una transició de fase, en 2, 3 i 4 dimensions, en que la mag-
netització passa a ser espontània, en baixar per sota d’una certa Tc . En 1 dimensió veiem que el
que seria una mena de transició de fase es troba a 0K.
Per a H = 0 el sistema no té direcció preferida per a l’orientació dels spins, de manera que han
estat les fluctuacions qui han decidit si els spins s’alineaven cap a dalt (4D), o cap a baix (1D, 2D,
3D)
També, observem molta més fluctuació en 1 i 2 dimensions, degut a que el nombre d’spins
és molt menor, i suposadament, també degut a que les fluctuacions disminueixen en importància
quan incrementa la dimensió, però amb l’estudi que em fet no es pot provar.

4 Conclusions
Què n’he après?
Que realitzar un estudi complet d’una simulació requereix dedicació, i que els recursos computa-
cionals són més limitats del que voldríem. Especialment, incrementar la dimensió del problema,
tot mantenint les mides en cada direcció, és molt problemàtic. Això és degut a que l’ordre de
l’algorisme que fa la simulació és O(L2D ), és a dir, si tenim 10 caselles de longitud (L = 10),
multipliquem el temps que triga a executar-se l’algorisme per 100 cada vegada que incrementem
en 1 la dimensió.
Què he obtingut?
Un model molt capaç d’emular el model d’Ising, que fins i tot presenta comportaments que
a classe només hem dit de paraula, com la oscil·lació de la magnetització entre up i down, quan
el camp extern és 0, i quan estem a prop de la temperatura crítica, i que, amb algunes de les
simulacions temporals, no presentades en l’exercici, s’intueix com el 0 és un punt d’equilibri in-
estable per a la magnetització, com s’havia dit també de veu. (S’intueix, perquè, en acostar-se la
magnetització a 0, en sistemes d’un gran nombre d’spins, la variació de la magnetització s’alenteix)

És una pregunta que queda oberta si el model ideat és realment és una bona aproximació al
comportament dinàmic real. Hi ha una bona justificació per assegurar que així sigui?

5 Apèndix (Codi de la simulació)

El programa ha estat escrit en Python. Existeixen vàries versions del programa, amb petites
modificacions, aquesta és la que ha estat usada per a fer les gràfiques de magnetització que no
presenten dependència temporal, i ens mostren la transició de fase en cada dimensió.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import random

value = {’down’:-1, ’up’: 1}

debugejar = 0

#FUNCIONS
#Retorna cert amb probabilitat p
def coin(p):
if (not 1 >= p >= 0):
print(’error, no probabilitat normalitzada’)
return (random.random() < p)

#Retorna els elements del veïnat, tipus veïnat és una llista amb els v veins, que per a cada un s’
def retorna_veinat (tipus_veinat, posicio):
veins = list (np.zeros(D))
for i in range(D):
veins[i] = tipus_veinat[i] + posicio[i]
if debugejar == True:

6
 print(’veins’, veins)
print(Graella[veins])
return Graella[veins]

#Reinicia els valors de la graella a -1

def reset_down():
Graella = -np.ones(Mides)
return Graella

#Retorna l’energia dividida entre l’spin

def potencial(suma_spins):
return -suma_spins*J/2 - H

#Part del programa que calcula les probabilitats d’un spin

def nou_spin(suma_spins):
Pot = -potencial(suma_spins) # = -Energia/spin
if (debugejar == True):
print(’potencial efectiu’, -Beta*Pot)
#Calculem probabilitats sense normalitzar
S = 1 #Spin
p_up = np.exp(S*Pot/T)
S = -1
p_down = np.exp(S*Pot/T)
Q = p_up + p_down #Funció de partició
if (p_up > p_down):
#Fem servir p_down perquè és més petit i es comportarà millor numbèricament
p_down = p_down/Q
if (debugejar == True):
print(’prob down’, p_down)
if (coin(p_down)):
return value[’down’]
return value[’up’]
else:
#Fem servir p_up perquè és més petit i es comportarà millor numbèricament
p_up = p_up/Q
if (debugejar == True):
print(’prob up’, p_up)
if (coin(p_up)):
return value[’up’]
return value[’down’]

#simula steptime*maxtime passos, i retorna l’estat sencer en cada pas

def save_all_simulacio(imprimeix):
Graella_timelapse = np.array([Graella])
if imprimeix:
print (’Estat inicial’, Graella_timelapse)
for t in range(maxtime):
for p in range(steptime):
pos = tuple(np.random.randint(N, size = D) - 1) #Genera una posició aleatòria
if debugejar == True:
print (pos)
Graella[pos] = nou_spin(sum(retorna_veinat(Neumann, pos)))
if debugejar == True:
print (’valor introduït a’, pos, ’és’, Graella[pos])
Graella_timelapse = np.append(Graella_timelapse, [Graella], axis=0)
#Imprimim el percentatge pel que anem
if (interval and not t%interval):

7
 print (100*(t+1)/maxtime, ’%’)
if imprimeix:
print (’Estat final’, Graella_timelapse[maxtime*steptime])

return Graella_timelapse

#simula steptime*maxtime passos, i retorna l’estat sencer en cada pas

def magnetitzacio_simulacio(progres):
Magnetització = np.zeros(maxtime+1)
for t in range(maxtime):
Magnetització[t] = sum(np.reshape(Graella, Caselles))/Caselles
for p in range(steptime):
pos = tuple(np.random.randint(N, size = D) - 1) #Genera una posició aleatòria
if debugejar == True:
print (pos)
Graella[pos] = nou_spin(sum(retorna_veinat(Neumann, pos)))
if debugejar == True:
print (’valor introduït a’, pos, ’és’, Graella[pos])
#Imprimim el percentatge pel que anem
if (progres and interval and not t%interval):
print (100*(t+1)/maxtime, ’%’)

Magnetització[maxtime] = sum(np.reshape(Graella, Caselles))/Caselles

return Magnetització

############################
#PARÀMETRES DE LA SIMULACIÓ#
############################
#Paràmetres d’espai i temps
N = 10 #Mida de l’hipercub (L en l’exercici escrit)
D = 4 #Dimensions de l’hipercub
maxtime = 1000 #10*Nombre de intervals de temps fets per la simulació
steptime = int(pow(N,D)/10) #Nombre de passos efectuats en cada interval de temps

#SETUP
#Temps
if (debugejar == True):
maxtime = 1
time = np.array(range(maxtime+1)) #Array amb cada instant de temps
interval = int((maxtime)/20) #Serveix per indicar per quin percentatge de la simulació anem, 20 v

#Espai
#Generem l’hipercub ple d’uns
Mides = N*np.ones(D)
Mides = Mides.astype(int)
Graella = np.ones(Mides)
Caselles = pow(N,D)
#Creem el veïnat de Neumann
adj_1D = np.array([-1,1])
Neumann = np.zeros((D,2*D)) #Coordenada, numeració de les 2D posicions adjacents que estic mirant
for i in range(D):
j = 2*i
Neumann[i, j:j+2] += adj_1D
if debugejar == True:
print(’neumann’, Neumann)
Neumann = list(Neumann.astype(int))

8
#Paràmetres físics d’interacció
J = 1 #Self - interaction
Mag = [0, 0.02, 0.08, 0.2, 0.8] #Camp magnètic
Temp = np.arange(4.1, 0,-0.1) #Temperatura (1/Beta)

###########
#Simulació#
###########
Resultats = np.zeros((np.size(Mag), np.size(Temp)))

i = 0
for H in Mag:
j = np.size(Temp)-1
for T in Temp:
#Graella = reset_down()
magnetització = magnetitzacio_simulacio(False)
Resultats[i,j] = sum(magnetització[10:])/np.size(magnetització[10:])

plt.plot (time, magnetització, linestyle = ’-’, color =’orange’, marker = ’.’)

plt.savefig(’4D, 100 ut, mag ’ + str(H) + ’ temp ’ + str(T) + ’.png’)
plt.clf() # Clear figure
j -= 1
i +=1

np.savetxt(’4D.txt’, Resultats)