Tarea 2: Procesos de primer paso

Para entregarse el jueves, 19 de febrero de 2015, antes de las 14 horas.

LA TAREA SE HACE Y SE ENTREGA EN PAREJAS

Considérese un caminante aleatorio que vive en los enteros. Es simétrico, es decir, en cada paso, brinca a la izquierda o al derecha, los dos con probabilidad $\frac{1}{2}$. Empieza en $1$.

Estudiaremos el tiempo de primer paso a $0$, es decir, ¿cuándo llegará por primera vez el caminante a $0$? A esta variable aleatoria la llamaremos $\tau$.

Preguntas

[1] Escribe una función que simule al caminante aleatorio, empezando en $1$ hasta que llegue a $0$. El caminante vive en una caja de tamaño $L+1$, es decir en $\{0, 1, \ldots, L-1, L\}$, y la función debe tomar $L$ como parámetro.

Hay una frontera reflejante en $L+\frac{1}{2}$: si el caminante está en $L$ e intenta brincar a la derecha, se refleja y se queda en donde estaba.

La función regresa el tiempo que tardó en llegar a $0$.

[2] Escribe una función que calcule el tiempo promedio $\langle \tau_L \rangle$ en llegar a $0$ para un sistema de tamaño $L$, sobre un número de corridas $N$.

[3] Dibuja el tiempo promedio $\langle \tau_L \rangle$ en función del tamaño $L$. ¿Cómo escala el tiempo promedio con $L$? ¿Qué pasa cuando $L \to \infty$?

[4] Escribe una función que calcule la distribución de probabilidad de $\tau_L$.

[5] Dibuja la distribución de probabilidad $f_{\tau_L}(t)$ de $\tau_L$ para distintas $L$ en una sola gráfica. ¿Cómo escala la cola de la distribución?

[6] ¿Cómo se ve la distribución de $\tau_\infty$? ¿Cómo es su cola? ¿Qué implica para el tiempo promedio de $\tau_\infty$?

[1]



In [1]:

    
function paso(x::Int, L::Int, p)
    if rand() < p
        x += 1
    else
        x -= 1
    end
    
    if x == L+1 #Si la caja se acaba..
        x = L   #se refleja
    end
    
    x
end

function caminata(L::Int, p=0.5)
    x = 1
    τ = 0
    
    while x != 0
        x = paso(x, L, p)
        τ +=1
    end
    
    τ
end









    Out[1]:





caminata (generic function with 2 methods)



In [2]:

    
caminata(10)









    Out[2]:





1

[2]



In [2]:

    
function taupromedio(L::Int, N::Int)
    corridas = Array(Int,N)
    
    for i in 1:N
        corridas[i] = caminata(L)
    end
    
    L, N, mean(corridas)
end









    Out[2]:





taupromedio (generic function with 1 method)



In [4]:

    
L = 10; N = 10_000
taupromedio(L, N)









    Out[4]:





(10,10000,20.238)



In [5]:

    
L = 10; N = 100_000
taupromedio(L, N)









    Out[5]:





(10,100000,19.83414)

No hay tanta diferencia entre $10^4$ y $10^5$ corridas, vamos a usar el primer valor para que tome menos tiempo.

[3]



In [3]:

    
using PyPlot









    



INFO: Loading help data...



In [7]:

    
function tauVsL(Ls)
    N = length(Ls)
    ts = Array(Float64,N)
    
    figure(figsize=(5,3))
    xlabel("L")
    ylabel("<τ>")
    
    for i in 1:N
        ts[i] = taupromedio(Ls[i], 10_000)[3] #Usamos 10_000 corridas para sacar el promedio
    end
    
#     gca()[:set_xscale]("log")
#     gca()[:set_yscale]("log") 
    plot(Ls,ts,"o-")
end









    Out[7]:





tauVsL (generic function with 1 method)

Muestra de $L$ lineal



In [8]:

    
Ls = [10:50:1000]
tauVsL(Ls);

Logarítmica



In [17]:

    
Ls = [10^i for i in 0:5]
tauVsL(Ls);

De las dos gráficas anteriores, concluimos que $<\tau>$ escala linealmente con $L$ y si $L \to \infty$, $<\tau>$ diverge.

[4]



In [17]:

    
function distribucion(L::Int, N::Int) #N el número de corridas
    corridas = Array(Int,N)
    for i in 1:N
        corridas[i] = caminata(L)
    end
    
    m = maximum(corridas)
    dist = zeros(Int, m)
    
    for c in corridas
        dist[c] += 1
    end
    
    dist/N
end









    Out[17]:





distribucion (generic function with 1 method)



In [18]:

    
L = 20; N = 10_000
distribucion(L, N)









    Out[18]:





2347-element Array{Float64,1}:
 0.5043
 0.0   
 0.1235
 0.0   
 0.0626
 0.0   
 0.0416
 0.0   
 0.0276
 0.0   
 0.0198
 0.0   
 0.0161
 ⋮     
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0   
 0.0001

[5]

Dibujemos la distribución para distintas $L$



In [10]:

    
Ls = [20, 100, 500]
N = 10_000

figure(figsize=(5,3))
xlabel("t")
ylabel(r"\f_{\tau_L}(t)") #No jala el rendering

for L in Ls
    plot(distribucion(L,N)[1:40], "x") #Estamos cortando las colas
end

Para $t$ pequeña, el comportamiento de las diferentes distribuciones de $\tau_L$ es similar. ¿Cómo se comportan las colas que tuvimos que cortar?

Podemos tomar, como medida de la cola, la longitud de la distribución:



In [23]:

    
function colas(Ls, N::Int)
    out= Int[]

    for L in Ls
        push!(out, length(distribucion(int(L),N)) )
    end
    
    out
end









    Out[23]:





colas (generic function with 1 method)



In [24]:

    
Ls = [20, 100, 500]
N = 1000

c = colas(Ls,N)









    Out[24]:





3-element Array{Int64,1}:
   2377
  22443
 395918



In [27]:

    
Ls = [10^i for i in 1:0.5:5]
N = 10_000

@time c = colas(Ls, N);









    



elapsed time: 189.581935573 seconds (32870575088 bytes allocated, 1.96% gc time)



In [28]:

    
figure(figsize=(5,3))
xlabel("L")
ylabel("max{τ}")
gca()[:set_xscale]("log")
gca()[:set_yscale]("log")
plot(Ls, c, "o-");

La cola crece aproximadamente linealmente con $L$.

[6]



In [ ]: