Boltzmann, mais uma prévia

Pessoal, antes das derivações da Equação de Boltzmann, gostaria de introduzir algo de sua “filosofia”. Relaciona-se com o fato de que num sistema fechado a entropia aumenta. Um exemplo muito citado envolve o seguinte experimento: em duas caixas coloque um certo número de bolas N e, aleatoriamente, transfira uma dessas bolas para uma caixa vazia no primeiro passo. No passo seguinte, peque uma bola (pode ser a mesma que você havia transferido, uma vez que o processo é randômico) e passe para a outra caixa. Repita o processo muitas vezes. Algo nos diz que aproximadamente 50% das bolas estarão numa caixa, e 50% na outra. Mas por quê? Vamos chamar as bolas de 1, e os espaços vazios de zero. Se temos duas bolas, podemos ter as seguintes combinações de bolas nas duas caixas:

00|11

10|10, 01|10, 10|01, 01|01

11|00

O número de combinações é N!/k!(N-k)! = 4!/[2!(4-2)!] = 6 (k é o “número de bolas”). Agora se nos concentrarmos em uma das caixas, e trocarmos N por n, vemos que temos quatro configurações:

00 (nível 1)

01, 10 (nível 2)

11 (nível 3)

Neste caso o número de combinações envolve diferentes valores de k para cada nível (número de 1’s permutados em cada nível). Para o nível 2 existem n!/[k!(n-k)!] = 2!/[1!(2-1)!] = 2 jeitos de se permutar as “bolas”. Para n = 3, temos o seguinte número de combinações:

000 (nível 1) => 3!/[0!(3-0)!] = 1

100, 010, 001 (nível 2) => 3!/[1!(3-1)!] = 3

110, 101, 011 (nível 3) => 3!/[1!(3-1)!] = 3

111 (nível 4) => 3!/[3!(3-3)!] = 1

Para n = 4:

0000 (nível 1) => 4!/[0!(4-0)!] = 1

1000, 0100, 0010, 0001 (nível 2) => 4!/[1!(4-1)!] = 4

1100, 1010, 1001, 0101, 0011, 0110 (nível 3) => 4!/[2!(4-2)!] = 6

1110, 1101, 1011, 0111 (nível 4) => 4!/[1!(4-1)!] = 4

1111 (nível 5) => 4!/[4!(4-4)!] = 1

Ok, já chega. Se considerarmos que cada um dos estados acima é igualmente provável, aparentemente a probabilidade de se obter um estado com aproximadamente metade das bolas (n/2) é maior. Por exemplo, se observarmos todas as combinações acima, temos 1 + 4 + 6 + 4 + 1 = 16 = 2^4. Ou seja, de uma maneira geral, para um máximo de k bolas numa das caixas, temos 2^k combinações. A probabilidade de obter um dos estados é a soma das probabilidades individuais dividida pelo número total de combinações. Ou seja, a probabilidade de se obter todas as bolas num dos lados da caixa seria 1/16 (em torno de 6% de um número grande de permutações randômicas) enquanto para duas bolas num dos lados temos uma probabilidade de 6/16 (~37,5%). Esse mesmo exemplo geralmente é apresentado na forma de sorteios cara ou coroa nos livros de estatística.
Bom, agora sabemos que a probabilidade de uma configuração de bolas (k bolas em uma das caixas, onde cabem n bolas ou mais) é proporcional ao número de arranjos possíveis com estas bolas numa das caixas. De fato o estado mais provável é o com a metade das bolas numa delas (k provável = k* = n/2)? Bom, sabemos que o máximo de uma função pode ser obtido igualando-se sua derivada em relação à variável independente a zero. Se f(n,k) = n!/[k!(n-k)!], é bem conveniente obter-se o máximo do logaritmo de f(n,k), pois variações em fatoriais ocorrem em ordens de grandeza:

ln [f(n,k)]= ln n! – ln k! – ln (n-k)!

Vamos considerar também que temos um número muito grande de bolas e uma caixa igualmente espaçosa, para convenientemente podermos usar a aproximação de Stirling:

ln n! ~ n x ln n – n

(obs.: o símbolo ‘~’ significa que ln n!/[n x ln n – n] –> 1 quando n –> ∞)

ln [f(n,k)] = n x ln n – n – k ln k + k – (n-k) ln (n-k) + (n-k)
ln [f(n,k)] = n x ln n – k ln k – (n-k) ln (n-k)
ln [f(n,k)] = n x ln n – k ln k – n ln (n-k) + k ln (n-k)

Tirando a derivada com relação à k:

d{ln [f(n,k)]}/dk = – ln k – (k/k) – n x (-1)/(n-k) + ln (n-k) + k x (-1) /(n-k)
d{ln [f(n,k)]}/dk = – ln k – 1 + n/(n-k) + ln (n-k) – k /(n-k)
d{ln [f(n,k)]}/dk = – ln k + ln (n-k) = ln [(n-k)/k]
ln [(n-k*)/k*] = 0
(n-k*)/k* = e^0 = 1 => k* = n/2

Bom, agora podemos fazer um experimento. Escrevi um pequeno script no Scilab para verificar esta tendência, num primeiro caso com 100 bolas. Resumidamente ele funciona como se segue: uma matriz 10 x 10 é minha caixa, onde os 1’s representam as bolas e os 0’s representam os espaços vazios. A cada procedimento iterativo, uma bola ou um espaço é sorteado, e se houver uma bola ela é retirada, se não houver nada uma bola (“da outra caixa”) é posta no lugar. Repete-se o processo, que acompanho de duas maneiras. Uma delas é pela soma dos números da matriz. O máximo é 100 (todas as nesta caixa) e o mínimo é 0 (todas as bolas fora desta caixa). Esperamos, portanto, que os resultados tendam para ~50% de 1’s na matriz, com uma soma de aproximadamente 50. De fato, isto é observado para 1000 iterações, começando de um lado da caixa cheio (vermelho) ou vazio (azul):

Iteração 1

O script para rodar este cálculo é o seguinte:

M=[zeros(10,10)]’;// Linha 1 – para o caso de começar num uma caixa vazia
x=[1,2,3,4,5,6,7,8,9,10]’; // Linha 2
for i=1:1000 // Linha 3
y=grand(30,’prm’,x);// Linha 4
a=y(5,5);// Linha 5
b=y(7,7);// Linha 6
M=[[M(1:(b-1),:)] //Linha 7
M(b,1:(a-1)),abs(M(b,a)-1),M(b,(a+1):10)//Linha 8
M((b+1):10,:)];//Linha 9
plot(i,sum(M),’r*’); //Linha 10
end //Linha 11

O script está horrível, uma vez que não entendo muito de programação, mas usei alguns atributos matemáticos e um pouco de persistência para chegar nesta rotina. Explicando brevemente o que fiz no Scilab. Primeiro tive que construir uma matriz que só tem 0’s e 1’s. Comecemos, por exemplo, com uma matriz só de zeros, que é o caso do script acima. Esta condição inicial é especificada na linha 1, que diz que M é uma matriz 10 x 10 só composta por zeros. Nesta matriz quis escolher aleatoriamente uma célula, de modo que se houver 0 nela, ele se transforma em 1, e vice-versa. Neste caso há dois problemas. Primeiro é como escolher aleatoriamente uma célula da matriz. Segundo é como fazer essa operação mágica de 0 para 1 e 1 para 0. O primeiro problema pode ser resolvido sabendo-se que, tendo uma matriz 10 x 10, se arranjarmos uma maneira de escolher aleatoriamente um número inteiro entre 1 e 10, podemos usar estes números aleatórios para escolher uma linha e uma coluna aleatoriamente. Deste modo escolhemos a célula da matriz M de modo randômico. Ok, mas como escolher um número entre 1 e 10 randomicamente no Scilab? Cara, essa eu fiz na força bruta. Primeiro fiz um vetor x com os números que desejo escolher randomicamente (entre 1 e 10), este comando estando na linha 2. Depois tive que criar uma matriz de permutações aleatórias destes valores. Para isso usei o comando ‘grand’ (linha 4), que faz uma matriz (neste caso y) com 30 (escolhi esse valor) permutações dos números do vetor x. Por isso o ‘prm’, de permutações. Na linha 3 há o começo de um ciclo iterativo de operações. Quando escrevo ‘for i=1:1000’ digo “faça o que escrever abaixo, até quando disser ‘end’, ou seja, ‘pare!’” por 1000 vezes. A variável de contagem será o ‘i’, que vai crescer de 1 a 1000. Ou seja, essa operação de construção da matriz y será repetida 1000 vezes, e como ela é construída por permutações aleatórias, eu posso escolher uma célula desta matriz, e a cada valor de ‘i’ ela possuirá um valor diferente entre 1 e 10. Foi o que fiz nas linhas 5 e 6. Escolhi a célula na linha 5 e coluna 5 da matriz y como um valor ‘a’, e uma célula com linha e coluna 7 como um valor ‘b’. Com estes valores posso escolher uma linha e uma coluna da matriz M de maneira aleatória, uma vez que a linha escolhida terá valor ‘b’ e a coluna o valor de ‘a’.
O segundo problema é a operação para transformar 0 em 1 ou 1 em 0. Essa não é tão difícil. Se o valor da célula é ‘u’ (0 ou 1), então o módulo de u-1 obedece este pré-requisito, uma vez que |0-1| = 1 e |1-1| = 0. Logo podemos aplicar a operação numa célula da matriz M escolhida aleatoriamente (o comando de módulo no Scilab é ‘abs’, como pode-se observar na linha 8). Agora é combinar a solução dos dois problemas para construir uma nova matriz M, que terá uma célula na linha ‘b’ e na coluna ‘a’ submetida à operação. Essa nova matriz pode ser construída como fiz nas linhas 7-9. Os códigos que usei podem ser melhor entendidos a partir da figura abaixo:

M

Para acompanhar o processo podemos plotar o valor da soma dos algarismos de M (no mínimo 0 e no máximo 100) para cada iteração. Essa abordagem é usada na linha 10, que mostra o gráfico anteriormente apresentado, com o valor de ‘i’ (número da iteração) nas abscissas e o da soma dos algarismos da matriz (‘sum(M)’) nas ordenadas. Finalmente na linha 11 tem escrito ‘end’ para fechar o ciclo iniciado pelo ‘for’. Esse processo se repete, começando com uma matriz cheia de zeros (neste exemplo) e tendo suas células permutadas entre 1 e 0 a cada iteração.
Aos bravos que chegaram até este ponto, forneço uma maneira mais qualitativa de observar a evolução do sistema, mas muito interessante, que é representar a matriz como quadrados em que 0’s são de uma cor (azul) e 1’s de outra (verde).

x=[1:1:50]’; // maneira mais elegante de fazer um vetor [1,2,…,50]’, sem precisar escrever todos os algarismos, como fiz antes para ser didatico
M=[zeros(50,50)]’;
for i=1:1000
y=grand(30,’prm’,x);
a=y(5,5);
b=y(7,7);
M=[[M(1:(b-1),:)]
M(b,1:(a-1)),abs(M(b,a)-1),M(b,(a+1):50)
M((b+1):50,:)];
Matplot(M+2*ones(50,50))
end

Iteração 2

O script é essencialmente o mesmo, com a exceção do tamanho da matriz, desta vez usei uma 50 por 50 ao invés de 10 por 10 (maior e mais legal de ver evoluir), e do comando ‘Matplot(M+2*ones(50,50))’. Ele representa os elementos da matriz como quadrados com cores correspondentes aos números contidos neles. Eu acrescentei à matriz M uma outra matriz 50 por 50 contendo só valores 2 para que pudéssemos ver as cores (isso porque 0 e 1 não dá pra ver, portanto esta operação troca o processo para 2 e 3, de cores azul e verde, bem visíveis).

Aos poucos que acessam este blog, peço desculpas pela demora de sempre em submeter os posts. Ela ocorre porque, na verdade, levo mais tempo pra escrever didaticamente o que fiz do que pra fazer (como no caso deste post). Mas temo que vala a pena, pois dou um duro danado pra expandir nossos horizontes. Um abraço e nos vemos em breve, ou assim espero.

Advertisements
This entry was posted in Estatística, Físico-química. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s