Introducción

Supongamos que uno se encuentra aburrido, por lo que se plantea la siguiente actividad. Sobre una línea recta, se lanzará una moneda, si es sol, se avanzará un paso y si no, se retrocederá. Este es un ejercicio sencillo, por lo que nos volvemos a aburrir y ahora vemos una cuadrícula en el piso; aquí, hay cuatro posibilidades de movernos. No satisfechos con esto, encontramos un edificio con cuartos cuadrados del mismo tamaño, donde en cada cuarto existe una escalera para subir y bajar. Así, existen 6 movimientos posibles en cada cuarto.

Finalmente, en el mismo edificio, decidimos llevar una cuenta en la cabeza, sólo enteros, aumentando o disminuyendo en una unidad. En cada cuarto hay 8 opciones, moverse a los cuartos de adelante, atrás, izquierda, derecha, arriba, abajo, aumentar la cuenta, disminuir la cuenta.

Con esto, se puede plantear la pregunta, ¿En qué casos la persona regresará al origen de la caminata? Es importante notar que aunque la cuenta del último caso no sea visible, esa también debe regresar a su origen.

Marco Teórico

Las caminatas aleatorias son procesos estocásticos que describen un camino, éste consiste de una sucesión de pasos aleatorios sobre un espacio; usualmente los enteros. Un ejemplo sencillo de una caminata aleatoria es una sobre la recta numérica \(Z\) inciando en 0 y cada paso siendo +1 o -1 con misma probabilidad.

Una caminata aleatoria es recurrente cuando con probabilidad 1, se regresa al origen; y será transitoria en otro caso. Un resultado importante en la teoría de las caminatas aleatorias es el Teorema de Póyla, el cual muestra que una caminata aleatoria sobre una cuadrícula de dos dimensiones es recurrente, pero una en tres dimensiones no lo es.

La probabilidad de retorno en dimensiones \(d>3\) no tienen forma cerrada conocida, por lo que es de interés calcularlas.

Modelo Matemático

La cuadrícula o latiz en \(n\) dimensiones corresponderá a \(Z^n\) y las probabilidades de transición serán equiprobables entre las \(2*n\) opciones, para calcular la probabilidad de retorno, sólo se tomará el número de casos favorables sobre los totales.

Código

#Caminata en 1 dimension
rwone<-function(n,plotrw=F){
  posx<-0
  pos<-c(0)
  count<-0
  for(i in 1:n){
    count=count+1
    dir=rbinom(1,1,.5)
    if(dir==1){
      posx=posx+1
    }else{
      posx=posx-1
    }
    if(plotrw) {
      pos=c(pos,posx)
      }
    if(posx==0){
      if(plotrw){
        #print(pos)
        return(pos)
      } 
      return(T)
      break()
    }
  }
  return(F)
}

idk=rwone(1000,T)
print(idk)

## [1] 0 1 0

plot(0:length(idk),rep(NA,length(idk)+1),ylim = 0+6*c(1,-1))
lines(0:(length(idk)-1),idk)

test=numeric()
for (i in 1:100) {
  test[i]=rwone(1000000)
}
mean(test)

## [1] 1

#Caminata aleatoria 2 dimensiones
rwtwo<-function(n,plotrw=F){
  posx<-0
  posy<-0
  pos<-matrix(NA,ncol=2, nrow = n)
  count<-0
  for(i in 1:n){
    count=count+1
    
    if(plotrw) {
      pos[i,]=c(posx,posy)
    }
    
    dir=sample(1:4,1)
    switch (dir,
      {posx=posx+1},
      {posx=posx-1},
      {posy=posy+1},
      {posy=posy-1}
    )
    if(posx==0 & posy==0){
      if(plotrw){
        return(pos)
      } 
      return(T)
      break()
    }
  }
  return(F)
}

plot(rwtwo(10000,T), type="o")

test=numeric()
for (i in 1:100) {
  test[i]=rwtwo(1000000)
}
mean(test)

## [1] 0.88

#Caminata aleatoria en 3 dimensiones
library(plotly)

## Warning: package 'plotly' was built under R version 3.6.1

## Loading required package: ggplot2

## Warning: package 'ggplot2' was built under R version 3.6.1

## 
## Attaching package: 'plotly'

## The following object is masked from 'package:ggplot2':
## 
##     last_plot

## The following object is masked from 'package:stats':
## 
##     filter

## The following object is masked from 'package:graphics':
## 
##     layout

rwthree<-function(n,plotrw=F){
  posx<-0
  posy<-0
  posz<-0
  
  pos<-matrix(NA,ncol=3, nrow = n)
  
  count<-0
  for(i in 1:n){
    count=count+1
    dir=sample(1:6,1)
    
    if(plotrw) {
      pos[i,]=c(posx,posy,posz)
    }
    
    switch (dir,
            {posx=posx+1},
            {posx=posx-1},
            {posy=posy+1},
            {posy=posy-1},
            {posz=posz+1},
            {posz=posz-1}
    )
    if(posx==0 & posy==0 & posz==0){
      if(plotrw){
        return(pos)
      } 
      return(T)
      break()
    }
  }
  return(F)
}
df<-as.data.frame(rwthree(100000,T))
colnames(df)<-c("x","y","z")
p<-plot_ly(df,x =~x, y=~y, z=~z ,type = "scatter3d", mode="lines")
p

test=numeric()
for (i in 1:50) {
  test[i]=rwthree(1000000)
}
mean(test)

## [1] 0.36

#Caminata aleatoria en 4 dimensiones
rwfour<-function(n,plotrw=F){
  posx<-0
  posy<-0
  posz<-0
  post<-0
  count<-0
  for(i in 1:n){
    count=count+1
    dir=sample(1:8,1)
    switch (dir,
            {posx=posx+1},
            {posx=posx-1},
            {posy=posy+1},
            {posy=posy-1},
            {posz=posz+1},
            {posz=posz-1},
            {post=post+1},
            {post=post-1}
    )
    if(posx==0 & posy==0 & posz==0 & post==0){
      return(T)
      break()
    }
  }
  return(F)
}

test=numeric()
for (i in 1:50) {
  test[i]=rwfour(1000000)
}
mean(test)

## [1] 0.26

Conclusiones

Así, observamos que los valores simulados coinciden con los ya encontrados para \(d=3\) y además pudimos calcular el valor para \(d=4\). Concluimos que a partir del caso \(d>2\), no siempre se regresará al origen. Mejoras y consideraciones importantes serían la velocidad de ejecución del código y su presición; ya que resulta un compromiso. Refactorizar el código para utilizar cumsum podría ser benéfico para el tiempo de ejecución. El código podría ser una sola función que tome la dimensión como argumento. Graficar los ejemplos para \(d>3\) puede ser posible utilizando otras variables como tamaño, opacidad y color.