PERCOLAÇÃO - Uma implementação em R

Universidade Aberta2013/14

Mestrado em Tecnologias e Sistemas Informáticos Web-

Análise Formal de Redes Sociais (22128)-|-

PERCOLAÇÃO

David Fernandes

[email protected]

April 16, 2014

1 Teoria da Percolação

Suponha-se um meio poroso constituido por poros e canais que os ligam, dispostos numa estrutura emrede na qual os poros são os vértices e os canais as arestas. Suponha-se ainda que os referidos canais sãosusceptíveis de permitir a passagem de um �uido de acordo com uma probabilidade p conhecida e igualpara todos os canais. Este meio, que é um espaço Zd com dimensão d ∈ {1, 2, 3, . . . } é um modelo de

percolação de Broadbent e Hammersley. [Fontes, 2000] apud [Broadbent and Hammersley, 1957]

Este modelo tem aplicações em áreas tão diversas como a física, a ciência dos materiais, as redescomplexas e a edpidemiologia, entre outras. [Wikipedia, 2013]

[Fontes, 2000] refere alguns exemplos de modelos para espaços de dimensão 2 e 3:

• Z2 (espaços quadrados): difusão de uma epidemia numa região povoada ou a passagem de correnteatravés de um circuito electrónico;

• Z3 (espaços cúbicos): uma rocha mergulhada em água ou uma porção de pó de café numa cafeteira(com água quente por cima ou vapor por baixo).

A questão principal a que este modelo procura responder tem a ver com a probabilidade de se veri-�car percolação num meio, isto é, a probabilidade de existência de um caminho contínuo que atravessecompletamente o meio (horizontal ou verticalmente).

1.1 Terminologia

A chamada teoria da percolação utiliza uma terminologia própria: chama sites aos poros do exemploe os canais são apenas implicitamente perceptíveis pela existência de uma relação de vizinhança completa(horizontal ou vertical mas não diagonal) entre dois sites atingidos. Vejamos a Figura 1 como ilustraçãodestes conceitos.

1

Trata-se de um espaço 82, a vermelho temos os sites atingidos e os canais estão implicitamente rep-resentados na vizinhança completa entre dois destes sites. A um conjunto de sites atingidos vizinhoschama-se cluster.

Figure 1: Espaço 82 gerado aleatoriamente

Com o objectivo de permitir efectuar simulações em espaços Z2 foram implementadas algumas funçõesem linguagem R [RPR, 2014] que permitem, não apenas criar meios aleatórios mas também explorar aformação de clusters em geral, e com particular interesse a formação de clusters abrangentes, isto é, queatravessam completamente o meio.

Apresenta-se de seguida a descrição das várias funções implementadas bem como exemplos da suautilização e resultados obtidos.

2 Package �percolation�

2.1 percolation(size, p)

Esta função permite gerar espaços Z2 de forma aleatória. Recebe como argumentos a medida size do ladodo quadrado e a probabilidade p dos sites serem atingidos. A função retorna uma lista de três elementos:$size e $p replicam os argumentos utilizados e $lattice é uma matrix que representa o espaço, no qualos sites atingidos são representados pelo valor 1 e os restantes pelos valor 0.

> percolation(6, 0.3)

$size

[1] 6

$p

[1] 0.3

$lattice

[,1] [,2] [,3] [,4] [,5] [,6]

[1,] 1 0 0 1 0 0

[2,] 0 0 1 1 0 0

[3,] 1 1 1 0 0 0

[4,] 0 0 0 0 0 1

[5,] 0 1 0 0 1 0

[6,] 1 0 0 0 0 0

2

2.2 percolation.clusters(space)

Esta função tem como objectivo determinar os cluster formados num determinado espaço. Recebe comoargumento o espaço a analisar.

> m2 <- percolation(12, 0.4)

> m2$lattice

[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12]

[1,] 0 0 0 0 1 0 1 0 1 0 1 1

[2,] 0 0 0 1 1 0 1 0 0 0 0 0

[3,] 0 0 1 0 1 0 1 1 1 0 0 0

[4,] 0 1 1 1 1 0 0 1 0 1 0 0

[5,] 1 0 1 0 1 0 0 1 0 0 1 0

[6,] 0 1 1 0 1 0 0 0 0 0 1 1

[7,] 0 1 1 0 0 0 1 0 0 0 1 1

[8,] 1 0 0 0 1 0 0 0 0 0 1 1

[9,] 0 0 1 1 0 0 0 0 0 0 0 0

[10,] 0 0 0 1 0 0 1 1 0 0 0 0

[11,] 0 0 0 1 0 0 0 0 1 1 1 1

[12,] 1 0 0 0 1 1 1 0 0 1 1 1

> m2Clusters <- percolation.clusters(m2)

> m2Clusters

$lattice

[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12]

[1,] 0 0 0 0 4 0 8 0 11 0 14 14

[2,] 0 0 0 4 4 0 8 0 0 0 0 0

[3,] 0 0 4 0 4 0 8 8 8 0 0 0

[4,] 0 4 4 4 4 0 0 8 0 13 0 0

[5,] 1 0 4 0 4 0 0 8 0 0 15 0

[6,] 0 4 4 0 4 0 0 0 0 0 15 15

[7,] 0 4 4 0 0 0 9 0 0 0 15 15

[8,] 2 0 0 0 6 0 0 0 0 0 15 15

[9,] 0 0 5 5 0 0 0 0 0 0 0 0

[10,] 0 0 0 5 0 0 10 10 0 0 0 0

[11,] 0 0 0 5 0 0 0 0 12 12 12 12

[12,] 3 0 0 0 7 7 7 0 0 12 12 12

$size

[1] 12

$clusters

[1] 16 4 3 7 2 7 2 7

$h.spanning.clusters

integer(0)

$v.spanning.clusters

integer(0)

$w.spanning.clusters

integer(0)

A função retorna 5 elementos:

3

• $lattice consiste numa matriz com os clusters identi�cados. Note-se que os agrupamentos com-postos por apenas um site (e que formalmente não podem ser considerados clusters) se encontramtambém representados. No exemplo acima: 1, 2, 3, 6, 9, 11 e 13;

• $size o lado do espaço;

• $clusters uma lista com o número de sites de cada cluster ;

• $h.spanning.clusters uma lista com o número de sites de cada cluster horizontalmente abrangente,isto é, que atravessa o espaço da primeira à última colunas;

• $v.spanning.clusters uma lista com o número de sites de cada cluster verticalmente abrangente,isto é, que atravessa o espaço da primeira à última linhas;

• $w.spanning.clusters uma lista com o número de sites de cada cluster horizontal e verticalmenteabrangente, isto é, que atravessa o espaço da primeira à última colunas e da primeira à últimalinhas.

2.3 percolation.plot(space|clusters)

Esta função permite representar gra�camente tanto um espaço como os seus clusters. O argumento tantopode ser o resultado de uma função percolation como de uma função percolation.clusters.

> m1 <- percolation(5, 0.6)

> percolation.plot(m1)

Figure 2: Espaço

> c1 <- percolation.clusters(m1)

> percolation.plot(c1)

Nas Figuras 4, 5 e 6 apresentam-se outros exemplos:

3 Alguns resultados numéricos

Apresentamos de seguida alguns resultados numéricos obtidos por utilização das funções implemen-tadas.

4

Figure 3: Clusters do espaço da Figura 2

Figure 4: percolation.plot(p1 <- percolation(40,0.5))

Figure 5: percolation.plot(percolation.clusters(p1))

3.1 Validação da probabilidade p pelo Método de Montecarlo

Utilizando o Método de Montecarlo, foram gerados vários conjuntos de 2000 espaços com L = 20 ep = 0.324 arbitrário e calculamos depois os valores médios efectivamente encontrados. Como se pode

5

Figure 6: percolation.plot(percolation.clusters(percolation(size=100,p=0.6)))

veri�car, os valores encontrados aproximam-se de facto da probabilidade geradora p = 0.324 e é de supôrque esta aproximação fosse ainda maior se aumentassemos a dimensão da amostra.

> mean(mapply(function(...) sum(percolation(20, 0.324)$lattice)/400, seq(1:2000)))

[1] 0.3240962


[1] 0.3236975


[1] 0.3245663


[1] 0.3242625


[1] 0.3247575


[1] 0.3234975

3.2 O limiar de percolação

Uma propriedade importante da percolação diz que, no limite de um espaço in�nito, existe uma prob-abilidade limiar, pc = 0.5927 tal que:

6

• p ≥ pc se veri�ca a existência de um cluster abrangente;

• p < pc não existe nenhum cluster abrangente e todos os clusters são �nitos.

Para determinar o limiar de percolação começamos por escolher um valor para o número de sites L dolado do espaço. De seguida determinamos por simulação a probabilidade F (p) de que existe um cluster

abrangente para uma probabilidade de ocupação p. De seguida determinamos o valor de p para o qualF (p) = 0.5 que, uma vez que depende de L, denotamos por pc(L). [MacDonald, 2013]

Na Figura 7 mostramos uma simulação efectuada sobre amostras de 100 espaços para L ∈ {8, 12, 16}que permite veri�car esta propriedade:

Figure 7: Limiar de Percolação

7

4 Conclusão

A linguagem R mostrou-se muito apropriada para esta implementação. Graças às suas propriedadesfuncionais foi possível implementar alguns algoritmos com um reduzido número de linhas de código,nomeadamente pelo uso de funções de map. Por outro lado, as funções de plotagem permitiram de umaforma simples e e�ciente produzir os grá�cos que incluimos no trabalho.

Não houve preocupação com a e�ciência dos algoritmos e foram até detectadas algumas limitações, nãonas funções principais propriamente ditas de que Figura 6 é um exemplo, mas por exemplo no cálculo doLimiar de Percolação para espaços com L = 32. Há, portanto, trabalho a realizar nesta área.

Appendices

A Código fonte

##############################################################################

# lattice constructor

# size - side of the squared space

# p - probability of a site be occupied

#-----------------------------------------------------------------------------

percolation <- function (size, p) {

return (list("size"=size,

"p"=p,

"lattice"=ifelse(matrix(runif(size^2,0,1),nrow=size)<p,1,0)))

}

##############################################################################

# find cluster's information

# space -

#-----------------------------------------------------------------------------

percolation.clusters <- function(space) {

size = length(space$lattice[,1])

# recursive cluster detection

set <- function(ol, cl, col, row, value) {

ol[col, row] <- FALSE

cl[col, row] <- value

if(col>1) {

if(ol[col-1, row]==1 && cl[col-1, row]==0)

{

ret <- set(ol, cl, col-1, row, value)

ol <- ret$ol

cl <- ret$cl

}

}

if(col<size) {

if(ol[col+1, row]==1 && cl[col+1, row]==0)

{

ret <- set(ol, cl, col+1, row, value)

8

ol <- ret$ol

cl <- ret$cl

}

}

if(row>1) {

if(ol[col, row-1]==1 && cl[col, row-1]==0)

{

ret <- set(ol, cl, col, row-1, value)

ol <- ret$ol

cl <- ret$cl

}

}

if(row<size) {

if(ol[col, row+1]==1 && cl[col, row+1]==0)

{

ret <- set(ol, cl, col, row+1, value)

ol <- ret$ol

cl <- ret$cl

}

}

return(list("ol"=ol,"cl"=cl))

}

originalLattice <- space$lattice

clustersLattice <- matrix(replicate(space$size^2, 0), nrow=space$size)

clusterNumber <- 0

repeat{

if(length(which(originalLattice==1))==0) break;

# first occurence of an occupied site (if there is one)

rc <- which(originalLattice==1, arr.ind=TRUE)[1,]

clusterNumber <- clusterNumber + 1

ret = set(originalLattice, clustersLattice, rc["row"], rc["col"], clusterNumber)

originalLattice <- ret$ol

clustersLattice <- ret$cl

if(sum(ret$ol)==0) break;

}

# counting

summary <- table(clustersLattice)

# indexes of meaningfull clusters

indexes <- which(summary[2:length(summary)] > 1, arr.ind = T)

# find spanningClusters

firstRow <- clustersLattice[1,]

lastRow <- clustersLattice[size,]

firstCol <- clustersLattice[,1]

lastCol <- clustersLattice[,size]

9

# horizontal spanning clusters --

hsc <- unique(firstCol[which(firstCol[firstCol %in% lastCol]>0)])

# vertical spanning clusters |

vsc <- unique(firstRow[which(firstRow[firstRow %in% lastRow]>0)])

h <- summary[which(firstCol[firstCol %in% lastCol]>0)]

v <- summary[which(firstRow[firstRow %in% lastRow]>0)]

w <- summary[which(firstRow[hsc %in% vsc]>0)]

return(list("lattice" = clustersLattice,

"size" = size,

"clusters" = ifelse(length(summary)==1,NA,unname(summary[indexes+1])),

"h.spanning.clusters" = unname(h[which(!is.na(h))]),

"v.spanning.clusters" = unname(v[which(!is.na(v))]),

"w.spanning.clusters" = unname(w[which(!is.na(w))])))

}

##############################################################################

# general plot function

# space - space or clusters information

#-----------------------------------------------------------------------------

percolation.plot <- function(space)

{

# is a percolation

if(!is.null(space$p))

{

plot(x=c(0,space$size*10),

y=c(0,space$size*10),

xlab="",

ylab="",

xaxt='n',

yaxt='n')

# build graphic representation

foo <- mapply(function (x)

mapply(function(y)

rect(xleft = (y - 1) * 10,

ybottom = (x - 1) * 10,

xright = y * 10,

ytop = x * 10,

col = ifelse(space$lattice[x, y], 2, 0)),

1:space$size),

1:space$size)

}

else

{

lattice <- space$lattice

# is a cluster representation

plot(x = c(0,length(lattice[1,]) * 10),

y = c(0,length(lattice[1,]) * 10),

10

xlab = "",

ylab = "",

xaxt = 'n',

yaxt = 'n')

# array frequency of sites for each cluster number

# 0 1 2 3 4 5 6 7 8 9 10 11 <- cluster number

#64 3 9 6 4 4 1 4 2 1 1 1 <- number of sites

summary <- table(lattice)

# indexes of meaningfull clusters

indexes <- which(summary[2:length(summary)] > 1, arr.ind = T)

# indexes of single-site "clusters"

singleSites <- which(summary[2:length(summary)] == 1, arr.ind = T)

# build graphic representation

foo <- mapply(function (x)

mapply(function(y)

rect(xleft = (y - 1) * 10,

ybottom = (x - 1) * 10,

xright = y * 10,

ytop = x * 10,

# color of the square

col=ifelse(lattice[x, y] %in% indexes,

lattice[x, y] + 1,

# if we need to color single-site cluster's

ifelse(lattice[x, y] %in% singleSites,

0,

0))),

1:length(lattice[1,])),

1:length(lattice[1,]))

}

}

References

[RPR, 2014] (2014). The r project for statistical computing. http://www.r-project.org. [Online;accessed 30-January-2014].

[Broadbent and Hammersley, 1957] Broadbent, S. R. and Hammersley, J. M. (1957). Percolation pro-cesses i. crystals and mazes. volume 53, pages 629�641.

[Fontes, 2000] Fontes, L. R. (2000). Percolação - um modelo simples (e interessante) para um meioporoso. Matemática Universitária, (28):1�17. [Online; accessed 23-January-2014].

[MacDonald, 2013] MacDonald, J. (2013). Percolation. http://www.physics.udel.edu/~jim/

PHYS460_660_11S/percolation/percolation.htm. [Online; accessed 30-January-2014].

[Wikipedia, 2013] Wikipedia (2013). Percolation � wikipedia, the free encyclopedia. [Online; accessed29-January-2014].

11

Documents

PERCOLAÇÃO - Uma implementação em R