Lotofácil: técnica da mínima colisão

A lotofácil é uma loteria da Caixa Economica Federal do Brasil de aposta relativamente barata e que dá boas chances de acertos aos seus apostadores.

Além das bem conhecidas qualidades supracitadas, ela proporciona uma estrutura de funcionamento bastante interessante de ser estudada por amantes do campo de probabilidades e combinatória.

Matemática à parte, trata-se de uma loteria bastante popular e que pode servir também como boa opção (melhor que Megasena) pra apostadores não profissionais.

Nesse sentido, sabendo-se que em geral o apostador eventual dessa loteria faz apenas duas apostas simultaneas em um dado concurso qualquer, comecei a imaginar formas de otimizar tal dupla de aposta.

Foi a partir da premissa do apostador eventual e averso a riscos, que, através de diversos testes computacionais e matemáticos, cheguei ao método da colisão mínima, descrito em maiores detalhes no artigo constante em minha página pessoal (veja aqui o referido artigo).

Tal método é de simples memorização e garante maiores chances de algum ganho quando as combinações são apostadas em conjunto, do que se tivessem sido escolhidas puramente ao acaso. Para fazê-lo basta proceder da seguinte forma:

1. Escolha cinco dezenas e marque-as nas duas apostas;
2. Marque outras dez dezenas na primeira aposta;
3. Marque as dezenas restantes da segunda aposta que não constem na primeira.

Fica aqui então minha dica. Espero que seja de grande ajuda aos que arriscam a sorte em loterias apenas eventualmente.

Sistemas legados e números aleatórios

Recentemente precisei gerar números aleatórios em um sistema escrito em linguagem legada, no caso, o velho e confiável COBOL.

O objetivo era usar esses valores na chave primária de uma tabela, pois tinhamos como requisito que essa chave contivesse números sem significado, sorteados de tal forma que não fossem de fácil adivinhação, descartando-se assim o uso de um simples campo numérico autoincremental.

No caso, como a aplicação não precisava de primor estatístico e nem segurança criptográfica – além da linguagem não dar suporte a operadores binários – optei por implementar um simples gerador baseado em congruencia linear.

Nesse tipo de gerador, temos a seguinte relação recorrente:

O problema foi como escolher os três parâmetros de geração a, c e m de forma que possam ser processados em inteiros de 18 digitos (limitação imposta pela linguagem) e que tenha um ciclo de repetição o mais longo possível, isto é, percorra todos os números do conjunto de inteiros previamente definido antes que ocorra repetição dos elementos gerados.

Para calcular tais parâmetros, fiz uso da dica constante na própria página da wikipedia que diz como escolher valores que resultem em períodos longos de geração sem repetição.

Assim, com base no método citado no artigo, construí o roteiro abaixo (que é uma versão simplificada do roteiro original que utilizei):

1) Escolha um número máximo esperado para o numero aleatorio (MAX);
2) Procure o primeiro número PRIMO antes de: MAX / (3*3*3*3*3*2);
3) Parametro M = (PRIMO*3*3*3*3*3*2):
4) Parametro A = (PRIMO*3*2+1)
5) Definir o parametro C como 7.
6) Teste se:
6.1) A e 1 são congruentes em relação ao primo?
6.2) A e 1 são congruentes em relação a 3?
6.3) A e 1 são congruentes em relação a 2?

Vamos então a um exemplo prático.

Digamos que desejamos gerar números entre 0 e 9999, sendo que os números só devem se repetir quando não houver mais inteiros “sorteados”.

Seguindo os passos do roteiro acima temos:

1) MAX = 9999;
2) 9999 / 486 ~= 20. Nesse caso, PRIMO = 19;
3) Parametro M = (19*486) = 9234:
4) Parametro A = (19*3*2+1) = 115
5) Definir o parametro C como 7.
6) Teste se:
6.1) A e 1 são congruentes em relação ao primo? 115 mod 19 = 1.
6.2) A e 1 são congruentes em relação a 3? 115 mod 3 = 1.
6.3) A e 1 são congruentes em relação a 2? 115 mod 2 = 1.

Em sequencia, supondo-se a existencia da função LCG(a, c, m, semente_inicial), vejamos os primeiros numeros gerados com base na semente “1″:

LCG(115, 7, 9234, 1) = {122, 4803, 7546, 9035, 4824, 727, 506, 2793, 7246, 2237…}

Para atestar se o período alcançado pelos parametros calculados foi o mais longo possível, desenvolvi um pequeno programa que gera números aleatórios com base na LCG até que um número já sorteado apareça novamente (para períodos curtos, como o do exemplo, pode-se verificar isso até mesmo no MS-Excel).

Em todos os testes que fiz da LCG acima, o período foi de 9234 números até que ocorra repetição (isto é, período = m) , servindo assim para a finalidade proposta.

Geradores de números pseudo-aleatórios

O gerador de números pseudo-aleatórios mais usado no universo digital é o famoso método da congruencia linear, descrito no livro Numerical Recipes e adotado em diversas linguagens (dentre elas C, Delphi etc). Isso se deve, é claro, a sua imensa simplicidade de implementação:


X[n+1] = (a * X[n] + c) mod m
Onde:
a = 1664525
c = 1013904223
m = 2^32


Porém, tal gerador é comprovadamente ineficiente para criptografia ou simulações estatísticas, notadamente quando se precisa aplicar o método de Monte Carlo.

Existem diversos geradores disponíveis no mercado, dentre eles destaca-se o Mersenne Twister. Porém, embora globalmente aceito como o de melhor custo computacional versus beneficio estatístico disponível atualmente, é bastante complicado de se implementar para a maioria dos pobres mortais.

Uma alternativa interessante que descobri alguns anos atrás é um automato celular chamado pelo seu descobridor (Stephen Wolfram) como Regra 30.

Wolfram fez um verdadeiro estudo sobre esse automato, mas especificamente sobre a capacidade de ser usado como um gerador de bits pseudo-aleatórios, passando por diversos testes estatísticos.

O matemático propõe o algorítmo, inclusive, como fortemente apto a ser utilizado em criptografia.

Controvérsias a parte, a verdade é que a teoria por trás da Regra 30 é bastante simples. O algoritmo consiste em aplicar algumas operações lógicas entre os bits do número processado (algo muito parecido ao método LFSR), tal como a seguir:


bit[n]´ = bit[n-1] xor (bit[n] or bit[n+1])


Podemos implementar facilmente tal algoritmo em linguagem C usando três inteiros representando os bits envolvidos no método, e um quarto que guardará o resultado da operação aplicado a todos os bits, como a seguir:


int rule30rnd() {
static unsigned int a = 0x00FF00FF; // bit[n-1]
static unsigned int b = 0x9ABCDEF0; // bit[n]
static unsigned int c = 0xFF00FF00; // bit[n+1]
unsigned int d;
d = a ^ (b | c);
a = (d >> 1) | (d << 31); // bit[n-1] = result rotate right
b = d; // bit[n] = result bits
c = (d << 1) | (d >> 31); // bit[n+1] = result rotate left
return d;
}


No código acima tratamos o problema das bordas – comum nos automatos estudados pelo Wolfram, que teoricamente crescem infinitamente para os lados, mas fisicamente são limitados por uma memória finita – com rotações nos dois inteiros (bit[n-1] e bit[n+1]).

Para modificar a semente de geração, basta alterar o valor de qualquer um dos três inteiros principais.

É importante notar, porém, que a qualidade de geração é bastante influenciada pelos valores inteiros escolhidos como iniciais.

Nesse contexto, Wolfram propõe a escolha de valores que sejam o mais aleatórios possíveis como semente, além de sempre fazer alguns ciclos de geração (de tamanho variável, descartando o resultado) no inicio do programa, antes de utilizar de fato os valores gerados.

Loterias: pseudo teorias e seus problemas

É interessante como até hoje se vê na internet pessoas utilizando o velho esquema de dezenas atrasadas/adiantadas para montar seus jogos e testar sua sorte nas loterias.

Para quem não sabe, tal esquema consiste basicamente em contar em determinado período de tempo quantas vezes cada dezena da loteria em questão saiu, montando uma tabela ao estilo “dezena versus quantidade de sorteios que apareceu”. No passo seguinte estas são classificadas em dezenas “quentes” (ou sortudas, para aquelas que saíram mais vezes), e “frias” (ou azaradas, aquelas que saíram poucas vezes).

O uso do esquema varia. Enquanto alguns jogam somente nas dezenas quentes alegando estas estarem no momento com “sorte”, outros fazem o inverso: evitam as “mais” quentes sob o pretexto que estas já tiveram sorte por tempo de mais, portanto com grande chance desta “onda” mudar.

A verdade é que esse esquema é uma das falácias probabilisticas mais conhecidas em jogos de azar, sendo baseada, mais especificamente, na famosa lei das médias (e um pouco também na ilusão de agrupamento, que nos faz ver padrões onde não existem).

Para demonstrar que o que diz a lei das médias está errado, basta imaginar um jogo de cara ou coroa: o fato de sair duas caras consecutivas não garante que a próxima sairá coroa (como prega a lei), já que você pode muito bem estar na realidade no início de uma sequencia de várias caras.

Na verdade, não dá para dizer nem quando a sequencia de caras irá terminar, já que estatisticamente todas as sequencias devem sair em algum momento e em igual proporção. Isto é: três sequencias de coroas sairá em uma determinado intervalo de tempo mais ou menos na mesma proporção que três sequencias de caras.

Existe até uma fórmula estatística que calcula a quantidade de dezenas que estarão atrasadas ou adiantadas ao longo do tempo. O problema é que não dá pra dizer “qual” sequencia (ou dezena) atingirá “qual” tamanho em determinado instante do tempo.

Este, inclusive, é um perfeito exemplo de aplicação do modelo matemático de passeio aleatório (que por sua vez é usado no estudo do movimento browniano) e da eterna busca para saber “quando” o movimento neste passeio terá sua direção modificada.

O modelo de passeio aleatório mais simples é o caminhar do bêbado: neste temos uma linha imaginária onde um individuo alcoolizado deve seguir percorrendo indefinidamente. A cada passo de sua caminhada o bêbado decide (com igual probabilidade) se dá um passo para a direita ou para esquerda (ele não anda em linha reta), tudo em relação a tal linha, afastando-se ou reaproximando-se desta a cada momento.

O problema consiste em, uma vez iniciada a caminhada, identificar quanto tempo demorará para o bêbado voltar a cruzar a linha inicial (ou então, pelo menos, quando este passará a um padrão de aproximação ou distanciamento desta).

O problema do passeio aleatório é abordado também em antigas estratégias de estudo do movimento da bolsa de valores, tendo o princípio de onda de Elliott (que não tem bases científicas para apoiá-la, diga-se de passagem) seu maior exemplo.

Uma dica que dou para quem quer tentar a sorte em loterias da Caixa é ler meus artigos sobre MegaSena e LotoFácil, que dão dicas simples e estatisticamente confiáveis que podem, pelo menos, ajudar na escolha de suas apostas.

E para os loucos por bits e bytes, aconselho também a dar uma olhada nesse meu programa, que usa algumas das idéias contidas nos artigos.

 

Universo computacional

Nesse final de semana estava a assistir um documentário da History Channel sobre como surgiu a Teoria do Big Bang, quando comecei a pensar nas inúmeras pessoas envolvidas nesse empreendimento ao longo dos séculos e como estas utilizaram-se quase que exclusivamente da matemática como principal ferramenta de explicação da natureza.

Não me é grande surpresa o uso da matemática para esse fim, já que julga-se desde eras imemoriais ser esta a linguagem universal (ou de um ”Deus Geômetra Onipotente para quem o mundo é um imenso problema matemático“, como bem diria Leibniz). Porém, também não é surpresa todas as teorias derivadas desta serem falhas em algum ponto. Ora, ao contrário do que mundanamente se pensa, não é a matemática imperfeita como nos sugeriu Godel?

O teorema da incompletude de Godel nos diz que “a matemática não é fechada, isto é, é incompleta“. Assim, “sempre existirão questões e problemas que NÃO podem ser respondidas pelos axiomas matemáticos EMBORA estes problemas possam estar bem definidos nesta matemática. Além disso, mesmo que se introduzisse novos axiomas para resolver estes problemas, SEMPRE existirão novos problemas que não serão respondidos por ela“.

Isso nos leva à crer que, assim como acontece na física, na matemática precisamos de teorias novas cada vez mais precisas e próximas da realidade as quais possam nos trazer respostas à velhos problemas bem como novas questões a serem respondidas.

Na física inclusive, mais precisamente na mecânica quântica, é bastante comum utilizarem artifícios matemáticos como a chamada renormalização para fugir de alguns resultados indesejados (infinitos, divisões por zero etc). Sem falar de alguns “relaxamentos” das regras matemáticas que aqui acolá se encontra menção em trabalhos importantes, inclusive de Einstein como acusam alguns.

Nesse contexto, o livro A New Kind of Science de Stephen Wolfram nos propõe que nossa matemática mostra-se assim incompleta por ser um simples reflexo e resultado de estruturas mais básicas. Ele sugere que nossos axiomas matemáticos se apóiam em bases lógicas, isto é, podem ser representadas e reconstruídas através de regras simples em autômatos celulares (vide capítulo Systems Based on Numbers na supracitada obra).

Em sua exposição, Wolfram nos instiga com a idéia de que informações aparentemente aleatórias, como o valor de PI e os números primos, podem ser explicadas e calculadas em termos de interações lógicas.

Nesse prisma, não é difícil visualizar que interações lógicas podem simular nossa matemática, já que são através delas que nossos computadores atuais fazem cálculos, bem como entender a dificuldade da matemática em representar operações lógicas como AND, OR e NOT (“e”, “ou” e “não”) em termos de seus axiomas naturais.

Assim, podemos crer ser plausível a idéia de Wolfram de que a matemática esteja contida dentro dos axiomas da lógica, tendo as CAs (tão conhecidas na ciência da computação) como sua representação gráfica tal qual os gráficos cartesianos os são para a matemática.

Nesse contexto, não se conseguiria com a matemática expressar tudo que poderia-se fazer com a lógica binária. E não é por menos, já que na ciência da computação sabe-se que linguagens de um nivel maior não podem modelar corretamente linguagens de nível menor (que são, inevitavelmente, mais expressivas que as primeiras).

Dessa forma, por exemplo, não se consegue transpor um programa escrito nativamente em Assembly (com binário oriundo dessa linguagem de baixo nível) para uma linguagem de alto nível, como C ou Java. Nesse processo sempre se perde algo que a linguagem destino não consegue expressar.

Este é o motivo, na ciência da computação, da grande dificuldade na engenharia reversa de código binário: embora sempre seja possível “descompilar” programas binários que sejam oriundos de código de alto nível, se o binário contiver partes (ou totalmente) escritos nativamente em Assembly estas não são convertidas. Talvez até esta seja também o motivo da dificuldade da engenharia genética em “hackear” o DNA: por ser código nativamente escrito em uma linguagem de baixo nível (como descrito nesse ótimo artigo), perde-se sua representação direta em uma abstração maior.

Mas, voltando-se ao tema do universo computacional, toda essa proposta do livro sobre a possibilidade de simularmos situações complexas através de simples regras de automatos celulares e que nosso mundo talvez seja governado por elas reacende velhas questões, como por exemplo o eterno debate do “determinísmo Laplaciano x indeterminismo quântico“.

Podemos imaginar que, caso vivamos em um mundo determinista, o simples fato de estarmos imersos nesse “sistema fechado” nos impede de modelarmos estados futuros deste, pois para conseguirmos tal possibilidade precisaríamos:

1. não interagir com o sistema, a fim de evitar reações caóticas oriundas dessa interação (o que está de acordo com a visão da mecânica quântica de que o observador, pelo simples fato de observar, modifica o estado do objeto observado);
2. termos um simulador que funcione mais rápido que o próprio universo, a fim de podermos simular o instante inicial, passar pelo atual e chegar ao instante futuro em um tempo que possa ser humanamente mensurável.

Por estarmos imersos no universo, e não podermos fisicamente fazer um programa rodar mais rápido que a própria máquina que o executa, nos faz chegar à conclusão que nos é impossível visualizar estados futuros por meio de uma simulação perfeita.

Mas essa conclusão não exclui simulações imperfeitas e incompletas, como as que encontramos em todas as nossas teorias da física antiga e atual.

Mundo probabilístico

Imagine se cada decisão que você fizesse em sua vida fosse governada pela sorte, mais especificamente por um dado. Essa é a proposta do livro “The Dice Man“, do autor americano George Cockcroft.

Escrito na década de 70, a obra conta a estória de Luke Rhinehart, um fictício psiquiatra que, após deixar um dado ditar uma decisão sua depois de uma noitada de muito poker, passou a ter progressivamente uma vida aleatória, cada vez mais governada pelos dados.

“Utilizar a sorte para modificar o destino de sua vida é a forma mais extrema de jogo de azar” (Luke Rhinehart)

Rhinehart, para cada simples ação em sua vida, deixava sob o encargo de um dado decidir entre seis opções previamente definidas por ele para aquela ação. Para compor essa lista, ele seguia cinco regras básicas:

1. Não incluia nenhuma opção a qual não gostaria de realizar;

2. Lembrava-se sempre que uma aparente opção errada escolhida pelo dado poderia resultar num grande ganho no futuro;

3. Sempre incluia uma ação drástica como opção, por que, na vida, ações assim podem simplesmente mudar tudo;

4. No inicio de cada dia deixava o dado decidir se deve ou não usá-lo no restante do dia;

5. E, periodicamente ignorava, deliberadamente, todas as quatro regras anteriores.

Analisando sob o ponto de vista matemático, o estilo de vida escolhida por  Rhinehart é tão provável quanto qualquer outro modo de vida que escolhermos ou inventarmos, por mais estranha que possa parecer. Ainda mais se considerarmos que as decisões humanas (e da natureza, vide a genética que apoia-se em mutações aleatórias) estão mais próximas de escolhas ao acaso do que qualquer tipo de embasamento racional (vide nossos políticos que refletem, sob o ponto de vista da amostragem, nosso povo).

De fato, o universo parece bastante aleatório em pequena escala (como demonstrado pela Mecânica Quantica), e mais determinístico em grandes escalas (vide as teorias relativisticas), e, nós humanos, encontramo-nos bem no meio termo disso. Ou, pelo menos, é assim que nos parece.

O pesquisador britânico Stephen Wolfram, em seu livro A New Kind of Science, relata que o mundo natural consegue realizar computações somente até um máximo nível de poder computacional, e que, embora muitos sistemas atinjam esse nível na natureza, há uma gama imensa de sistemas aparentemente simples com comportamento computacional complexo e vice-versa. Além disso sistemas computacionalmente equivalentes não conseguem mimetizar eficientemente um ao outro (ou sistemas mais complexos).

Assim, para que dois sistemas computacionalmente equivalentes (por exemplo, PCs de configuração idêntica) consigam mimetizar as atividades intrisecas do funcionamento um do outro implicará: ou na necessária simplificação do modelo desse sistema (para que seja possível uma simulação parcial em tempo real); ou no relaxamento do fator tempo para que seja possível a simulação total mas em lentíssima execução. Em qualquer das situações, perde-se a visão real do sistema original, impossibilitando sua compreensão total pelo outro.

Wolfram argumenta, em certo ponto do livro, que enxergamos como aleatório qualquer coisa que seja de igual ou maior complexidade que nós mesmos. Esses sistemas nos parecem aleatórios por que são, pelo menos, equivalentes a nossa própria complexidade.

Levando isso para a vida aleatória de Rhinehart, embora esta nos pareça assim sem sentido, qualquer vida também nos pareceria se considerarmos a possibilidade de que o conjunto das inúmeraveis situações que vivemos no decorrer dos anos forme um sistema pelo menos de igual complexidade a nós mesmos (já que esta ter uma menor complexidade é, obviamente, uma impossibilidade). Assim, nos resta apenas analisá-los sob o prisma de modelos imprecisos de vidas, na tentativa vã de mimetizar tais sistemas.

Se a vida, como um conjunto de inúmeraveis escolhas, é assim tão computacionalmente intratável por parte de nós, como saber se nossas decisões estão, de fato, nos rendendo pontos para uma melhor situação futura?

Será que, na soma final, fazer escolhas aleatórias nos trará a mesma taxa de perdas/ganhos que decisões racionais?

A teoria da computação nos mostra que o aumento linear do número de escolhas leva a um crescimento exponencial do número de possibilidades finais. Isso, em última instância, leva à indecidibilidade, na qual reside antigas questões como o Problema do caixeiro viajante de onde podemos apenas obter soluções boas, mas não a garantia da ótima solução.

Assim, talvez, decisões racionais (como uma forma de algoritmo de escolha) nos traga soluções que consideramos pelo menos satisfatórias.

Com isso, parece que na vida abrimos mão da possibilidade estatística real da ótima solução (que pode ser simplesmente descartada no rol de opções de nosso algorítmo pessoal de escolha), em prol de alcançarmos pelo menos o satisfatório.

No fim, trocamos o ganho máximo duvidoso por um ganho menor, porém certo.

Nas ondas do wavelet

A análise numérica de dados é um vasto campo da matemática que tornou-se acessível ao público em geral com o barateamento dos computadores.

Livros como A Lógica do Mercado de Ações de John Allen Paulos, e o clássico Análise de Séries Temporais de Morettin & Toloi, ensinam, por exemplo, peripécias matemáticas que podem tanto ajudar à incautos investidores a como tentar prever e evitar as inconstâncias da bolsa de valores quanto a pequenas indústrias ajustarem sua linha de produção com base na previsão de vendas oriundas de tais técnicas.

A essa imensa literatura disponível, tanto física quanto no mundo virtual, soma-se os inúmeros softwares (muitos deles de custo inacessível a maioria dos mortais) que prometem, em rítmo de produção em massa, mastigar números e cuspir informações, estas últimas de valor inegavelmente estratégico para o incremento da eficiencia num mundo multi-conectado e competitivo de hoje.

Nesse contexto, dentro da minha modesta capacidade, tenho nas últimas semanas reservado tempo para estudar o método de programação genética linear como analisador numérico de dados. Como me deparei no programa que desenvolvi com alguns problemas relacionados a lenta convergência dos modelos encontrados para certas amostras (citado no post anterior), pensei em tentar caminhos alternativos para melhorar esse desempenho.

Com essa idéia na cabeça, comecei a desenvolver um novo programa que permite analisar dados numéricos a partir do método de wavelet (ou, em bom português: ondaletas).

O método de ondaletas surgiu como uma alternativa ao velho método da transformada de Fourier para análise de sinais, permitindo, dentre outras vantagens, uma análise temporal das informações escondidas na amostra estudada, coisa que o método de Fourier não permite pois este último analisa apenas as frequências alí contidas, e não o comportamento destas frequências ao longo do tempo.

Ondaletas são adotadas em diversos campos do saber, como a física (dinâmica molecular, astrofísica, geofísica, mecânica quântica), processamento de imagem (análise de EEG e DNA, clima, reconhecimento da fala e visão artificial), compressão de dados (o famoso JPEG 2000 utiliza essa técnica), em geral substituindo a já citada transformada de Fourier.

O algoritmo que utilizei no programa baseia-se no método discreto de Haars (matemático hungaro precursor desse método), que, a grosso modo funciona assim:

1. Lê-se dois itens da amostra;
2. Aplica-se a eles dois filtros de passagem (isto é, duas funções matemáticas pré-definidas, chamadas de low e high-pass);
3. Obtêm-se dois novos valores, onde cada qual é colocado em amostras diferentes, formando assim duas novas sequências da amostra original;
4. Volta-se ao item 1 até chegar ao final da amostra original.

Ao final do processo as duas novas amostras possuirão metade do tamanho da amostra original, sendo que representarão duas ondaletas dispersas ao longo do tempo, as quais estavam escondidas nos dados analisados.

Os filtros de passagem adotados para implementar o método discreto de Haars impressiona pela simplicidade. Estes foram:

Na imagem abaixo temos um exemplo do programa em funcionamento. Na tela, vemos o sinal de uma função senóide - gerada aleatóriamente – sendo quebrada em duas ondas de frequência menores.

Essa quebra pode ser feita em componentes ainda menores, até um limite imposto pelo tamanho da amostra estudada.

No programa inseri também uma função de forecast, permitindo inferir futuros valores que a amostra irá apresentar caso as ondaletas calculadas se mostrem corretas.

O passo seguinte será implementar uma regressão não linear como método adicional de forecast, bem como integrar esse programa ao de LGP que desenvolvi anteriormente e ver se com isso este último passa a gerar modelos mais precisos dos dados analisados.

Pequenos quadrados….

Ontem atualizei o programa LGPTester para utilizar o conhecidíssimo Método dos Mínimos Quadrados como função de escolha do indivíduo da população que melhor se adequa aos dados analisados.

Essa mudança provocou uma aceleração brutal no tempo de processamento do programa, fazendo-o encontrar mais rapidamente (e com maior qualidade) modelos que se ajustem aos dados analisados.

Na tela abaixo podemos visualizar o LGPTester modelando uma função senóide escolhida aleatóriamente. O programa conseguiu fazer a engenharia reversa dos dados e encontrar um código C que imite o comportamento da função original.

É uma pena que o mesmo ainda não se dá com dados oriundos de geradores pseudo-aleatórios, onde o LGPTester tende a convergir muito lentamente para um modelo coerente.

Um possível motivo para que isso ocorra talvez seja a necessidade ainda de inclusão de novas funções matemáticas (como módulo, por exemplo) ao leque disponível para o programa. Como as funções disponíveis são relativamente simples, talvez o programa só consiga modelar dados oriundos de fontes igualmente simples.

Outra possibilidade seria talvez a necessidade de avaliar os dados sob novos enfoques, rearranjando-os para facilitar a análise pelo programa. Nesse sentido, pretendo implementar três métodos que permitem analisar padrões escondidos em dados: wavelets, return maps e recurrence plots.

Comentarei tais métodos nos próximos posts, a medida que for implementando-os.