Observatório da Cultura Digital - Conexões Científicas 2009: Análise de padrões de conectividade

Conexões científicas – análise de padrões de conectividade

Relatório final das atividades desenvolvidas,período de 01/12/2008 a 31/05/2009

ConteúdoIntrodução............................................................................................................................................. 3

Um pouco de história........................................................................................................................4

Euler e as Pontes de Königsberg.................................................................................................4Erdös e o Universo Aleatório........................................................................................................5Milgram e os Seis graus de separação........................................................................................7A Internet...................................................................................................................................... 8

Um pouco de matemática.................................................................................................................9Definição...................................................................................................................................... 9O modelo Barabási-Albert............................................................................................................9Distribuição de graus..................................................................................................................10Distância média..........................................................................................................................11Coeficiente de Aglutinação.........................................................................................................12

Detalhes de Implementação............................................................................................................... 14Por que Drupal?..............................................................................................................................14Modularização................................................................................................................................ 14

Graph Module.............................................................................................................................14Graph API...................................................................................................................................14Graph Rendering........................................................................................................................16

Conclusão........................................................................................................................................... 17Bibliografia.......................................................................................................................................... 18Notas...................................................................................................................................................18Apêndice A – Código Fonte do Graph Module....................................................................................19Apêndice B – Código fonte do Flex Graph Rendering........................................................................29

IntroduçãoA abordagem de problemas reais utilizando a teoria dos Grafos a muito vem ganhando importância,

unido a esta, as possibilidades da informática e atualmente o crescimento da Internet e sua

crescente importância para disseminação de informações em proporções nunca antes imaginadas,

estabelece um novo paradigma científico. O presente trabalho possui como propósito a construção

de um software (de código aberto) para extração e análise de informações das redes sociais

estabelecidas na infovia, proporcionando gerar arquivos de imagem que representem a rede social e

sua representação na forma de grafos.

Os avanços tecnológicos, em particular a revolução que a informática proporcionou para a ciência é

indiscutível e irreversível, não obstante a matemática pode se valer dessa tecnologia para provar

alguns fatos sem as metodologias clássicas. Na base estrutural da informática encontram-se

aninhadas diversas idéias matemáticas e um dos produtos da informática que mais ganhou

importância em todos os ramos da sociedade, a Internet, pode ser entendida segundo a visão

matemática como um grafo, que se estende por todo o globo terrestre, se expandindo a cada dia.

O estudo do comportamento e da topologia deste tipo de grafo, não apresenta ainda material

conclusivo, principalmente em português, existindo poucos estudos na área.

Por isso, durante esse texto eu traduzi vários termos da literatura estrangeira para os seus

equivalentes em português, alguns, porém eu não consegui achar tradução razoável, optando então

por utilizar os termos técnicos em inglês. Isso aconteceu, por exemplo, com o termo principal desse

documento, Scale-free Networks, o qual a tradução aproximada para português seria “Redes livres

de Escala” ou “Redes de escala invariante” mas optar por elas dificultaria ao leitor interessado na

hora de buscar por mais literatura na Internet.

Um pouco de históriaA matemática por trás das Scale-free Networks é – como toda teoria dos grafos – intuitiva, o objetivo

desse capítulo é introduzir o leitor aos conceitos necessários e os motivos que justificam a pesquisa

em Scale-free Networks.

Euler e as Pontes de Königsberg

Leonhard Euler foi um matemático impar, o conjunto ainda hoje incompleto de sua obra – Opera

Omnia – soma 76 volumes em mais de 3 mil páginas1. Euler possui contribuições em praticamente

todas as áreas da matemática, tendo desempenhado um papel extremamente relevante no

desenvolvimento da matemática aplicada.

Seus trabalhos mostram várias aplicações das séries de Fourier, de diagramas de Venn e dos

números de Euler. Mas no escopo desse documento estamos particularmente interessados num

problema que levou a criação de uma área completamente nova da matemática, as Pontes de Königsberg, Königsberg era uma pequena cidade da Prússia (atualmente Kaliningrado, Rússia)

localizada as margens do rio Pregel, a aproximadamente 800km da casa de Euler em São

Petersburgo. Königsberg é dividida pelo rio em duas partes continentais e duas ilhas fluviais.

Figura 1 – Ilustração de Königsberg2 e suas Pontes em 1735

Os cidadãos de Königsberg se perguntavam se existe um caminho que atravesse as sete pontes

passando uma só vez por cada uma das pontes3. Euler não só provou que era impossível realizar tal

façanha como também forneceu em seu artigo as bases para a Teoria dos Grafos.

1 Pagina pra comprar os volumes http://www.springer.com/dal/home/birkhauser/historyofscience?SGWID=1-40295-2-121672-0

2 Copyright Wikipedia http://en.wikipedia.org/wiki/Image:Konigsberg_bridges.png 3 “Can one walk across the seven bridges and never cross the same one twice?”

http://en.wikipedia.org/wiki/Image:Konigsberg_bridges.png

http://www.springer.com/dal/home/birkhauser/historyofscience?SGWID=1-40295-2-121672-0&referer=www.springeronline.com&SHORTCUT=www.springer.com/sgw/cda/frontpage/0,11855,1-40295-2-121672-0,00.html


A genialidade da solução de Euler não se encontra na solução em si, mas em representar o

problema no que ele chamou de Grafo.

Um grafo é um conjunto de nós e arestas (arcos) usualmente representadas como pontos e curvas

respectivamente.

Figura 2 – Representação em grafo do problema de Konigsberg

A prova de Euler para a não existência de tal caminho se baseia numa simples observação. Nós

com número impar de arestas necessariamente são ou o ponto de partida ou o ponto de chegada, e

para que seja possível passar por todas as arestas uma e somente uma vez, é necessário que

existam dois nós com número impar de arestas ou nenhum 4. E essa propriedade não se aplica

somente a esse grafo, mais do que isso ela é inerente a todos os grafos, ela é chama de caminho

Euleriano.

Depois dessa contribuição inicial, os grafos vieram se tornar um das maiores áreas da matemática,

tornando-se imprescindíveis para a nossa compreensão de redes.

Erdös e o Universo Aleatório

Se existiu uma pessoa que pôde igualar o feito de Euler tanto em quantidade e quanto em relevância

da sua produção científica, essa pessoa foi Paul Erdös. Nascido na Hungria, filho de matemáticos,

desde de sua primeira infância Erdös se destacava por sua habilidade matemática. Com mais de

511 colaboradores diretos, ele publicou aproximadamente 1500 artigos durante sua vida5. Foi com

um conterrâneo, Alfréd Rényi, que Erdos escreveu o que seria a primeira tentativa de justificar como

as redes funcionam.

Imagine uma festa com centenas de convidados onde nenhum dos outros candidatos conheça os

outros. Eles vão começar a conversar, e depois – suponhamos meia hora – você encontrará vários

pequenos grupos de duas ou três pessoas. Essas pessoas depois de um tempo provavelmente

ficarão cansadas de conversar com o seu parceiro inicial e irão procurar novos pares.

Agora imagine isso como um grafo, cada convidado da sua festa é um nó, as arestas ligam os nós

(pessoas) que já conversaram entre si na festa.

Figura 3ª

Figura 3b

Figura 3c

Figura 3d

No primeiro momento ( ) ninguém se conhecia, logo o grafo se parecerá com o da figura 3a. Após

trinta minutos ( ), teremos vários pares de pessoas, como na figura 3b. E após um tempo

suficientemente grande, teremos um gráfico como o da figura 3d.

Formalmente, o que Erdös e Rényi definiram foi a determinação de um grafo pelo seguinte processo de

construção; comece com nós e nenhuma aresta, e a cada iteração adicione uma aresta ligando dois

nós aleatórios que não estivessem previamente ligados. É trivial que após iterações

obteremos um clique.

Milgram e os Seis graus de separação

Stanley Milgram foi um dos psicólogos mais controversos do século vinte. Seus experimentos mais

famosos são o chamado experimento Milgram, em que ele analisou a capacidade dos participantes de

obedecer a uma figura autoritária que os ordenava ações contrárias a consciência pessoal dos

mesmos6, e o experimento do mundo pequeno7.

Nesse experimento, o objetivo de Milgram era descobrir a distância entre duas pessoas nos EEUU. Ele

escolheu pares de pessoas de cidades e estados diferentes, para uma pessoa do par ele mandou um

pacote com a foto, nome e outras informações da outra, com as seguintes regras:

1. Adicione seu nome no final da lista;

2. Pegue um dos cartões postais, preencha seus dados e mande de volta para a Universidade

Harvard;

3. Se você conhece pessoalmente a pessoa alvo, envie esse pacote para ela;

4. Caso contrário não tente contatá-la diretamente, ao invés disso envie esse pacote para alguém

que você conheça pessoalmente e que você acredite que tenha mais chances de conhecer o

alvo pessoalmente do que você;

Os resultados foram impressionantes, as cartas não só chegaram aos seus alvos, como ele encontrou

um número médio de passos entre pessoa inicial e alvo de 5,5. Esse é um número muito pequeno,

mesmo se pensando que o experimento se resumiu a cidades no interior dos EEUU.

É óbvio que os resultados para pessoas de países diferentes devem ser maiores, mas isso não ofusca a

relevância dos resultados. Imagine um grafo da sociedade, em que os nós sejam as pessoas, e que

caso elas se conheçam mutuamente há uma aresta entre elas.

6 Mais informações em http://en.wikipedia.org/wiki/Milgram_experiment ,e em http://content.apa.org/journals/abn/67/4/371 7 “Small world Experiment”

Av. Prof. Lucio Martins, Trav. 4, Bl. 18 - Cidade Universitária - 05508-900 - São Paulo - SP - BrasilTelefones: (+55-11) 3091-6325 / 4925 Fax: (+55-11) 3815-3083

www.futuro.usp.br - [email protected]

http://content.apa.org/journals/abn/67/4/371

http://en.wikipedia.org/wiki/Milgram_experiment

Se a sociedade fosse uma rede aleatória, seria impossível conseguir um valor médio tão baixo, mesmo

que fossem escolhidas pessoas de cidades vizinhas. Parece que temos um problema no nosso modelo,

não parece factível que ele comporte uma distância média tão baixa.

No próximo caso vamos tentar aplicar o modelo a mais uma rede e ver se ela nos dá uma pista de qual

é o problema. O próximo modelo será a Internet.

A Internet

O maior repositório de conhecimento da humanidade que já existiu, apesar do meio bilhão de nós que

possui atualmente, a internet começou pequena. Há cinqüenta anos nem o mais visionário dos

escritores de ficção científica sonhava que tal idéia viesse a se tornar real. Como uma rede com 213 nós

em 1981 passa a ter 489.774.2698 nós 26 anos depois? Qual é a topologia dessa rede? Por que ela não

se desmantelou no meio do caminho?

Se a Internet fosse regida pelo modelo de redes aleatórias de Erdös e Rényi antes que a Internet

alcança-se um milhão de nós ela já demandaria mais recursos do que toda a capacidade computacional

que a humanidade possui agora. Logo existe algo muito errado no nosso modelo.

A internet não é aleatória. Imagine que você tenha um fio “infinito” e queira se ligar a rede, você se

conectaria ao velho computador do seu vizinho na periferia da rede ou ao servidor mais central que você

conseguisse alcançar?

As pessoas escolhem a se conectar ao ISP9 que tenha o melhor preço, ou a melhor velocidade, ou uma

série de outros motivos. Mas em geral isso significa que quanto maior for o ISP (quanto mais conexões

com outros ISPs ele tiver, quanto mais no centro da rede ele estiver) mais pessoas escolherão se

conectar a ele.

Assim como com os seis degraus de separação, o modelo de redes aleatórias não consegue explicar a

internet, muitas outras redes reais também não conseguem ser explicadas por essa teoria, e foi a

necessidade de explicar essas situações que levou a criação do modelo de Scale-free Networks, foco

deste documento, que definiremos no próximo capítulo.



Um pouco de matemática

DefiniçãoScale-free Networks são grafos de topologia não-trivial onde a distribuição dos graus dos nós da rede

segue uma lei de potência.

O modelo Barabási-Albert

O modelo de redes aleatórias pressupõe que dado um número fixo de nós, arestas são adicionadas

aleatoriamente ligando estes nós entre si, sem que nenhum nó seja acrescentado ou retirado do grafo.

Já as redes encontradas na vida real, pelo contrário, se baseiam firmemente em dois conceitos;

crescimento e anexação preferencial.

Começando com um pequeno grupo de pessoas, a sua rede de amizades vai crescendo com adição

esporádica de novos nós, isso é o que chamamos de crescimento. Mas mais do que isso, é muito mais

provável que você se torne amigo de um amigo de seus amigos do que de um estranho qualquer que

você encontre na rua, isso chamamos de anexação preferencial.

Da mesma forma, a Internet começou pequena, tendo somente dois computadores como nós, e foi

crescendo a cada nova máquina que foi ligada a rede. E na Internet também como na sua rede de

amigos, é o computador que possui mais conexões – provavelmente um servidor de algum ISP – o que

possui a maior probabilidade de que um computador recém adicionado à rede se conecte.

Estes dois ingredientes inspiraram a criação do modelo Barabási-Albert, o que levou ao primeiro modelo

com uma distribuição de graus em lei de potência. O algoritmo do modelo Barabási-Albert é o seguinte:

Começando com um número de nós iniciais ( ), a cada passo adicione um novo nó com

arestas ligando o novo nó a diferentes nós.

Na hora de escolher os nós aos quais o novo nó se conectará nós assumimos que a probabilidade de

que um nó um novo nó se conectará ao nó depende do grau do nó da seguinte forma:

Após iterações esse algoritmo resulta em uma rede com nós e arestas. Simulações

numéricas indicam que essa rede evolui para um estado de escala invariante com a probabilidade de

que um nó tenha arestas seguindo uma lei de potência com um expoente independente da

única variável do modelo, .



Distribuição de graus

Um dos resultados determinantes do modelo de Scale-free networks, é a sua distribuição de graus.

Definimos distribuição de graus como a uma função , onde dado um grau , é o número de

nós do grafo G que possua grau .

Figura 4 – Distribuição de graus de uma rede aleatória

A figura 4, mostra a distribuição de graus de um grafo construído utilizando o algoritmo de Erdös-Rényi,

que é uma distribuição chamada de Curva Bell. Basicamente a figura nos mostra que a maior parte dos

nós possui um mesmo grau .

Figura 5 – Distribuição de graus de uma Scale-free Network

Já a figura 5 mostra a distribuição encontrada em grafos construídos utilizando o algoritmo Barabási-

Albert, essa distribuição é chamada de lei de potência. Ao contrário da curva Bell onde a maior parte dos

nós tem grau , na Scale-free networks uma pequena quantidade de nós possui um muito

grande, enquanto a grande maioria possui um valor mínimo. Disso nos prova que o algoritmo Barabási-

Albert favorece com que os ricos enriquecem10 com relação ao grau .



Distância média

Chamemos de o número de arestas do menor caminho que ligue o nó e .

Figura 4 – Grafo com o menor caminho entre e realçado

Neste caso, .

Da mesma forma, chamamos de distância média de um grafo a somatória da distância mínima entre

cada nó do grafo para todos os outros, dividida pela quantidade de nós do grafo, ou seja, dado um grafo

G com um número n de nós:

Resultados experimentais11 indicam que redes Scale-free com grau médio e de tamanho n quando

comparados com redes aleatórias de mesmo tamanho e grau médio possuem uma distância média

menor, o que indica que a topologia livre de escapa é mais propensa a manter os nós uns próximos dos

outros do que a topologia homogênea dos grafos aleatórios.

Mais do que isso, foi descoberto que a distância média de um grafo cresce de forma aproximadamente

logarítmica com relação a n. Ou seja:

11 Ver R. ALBERT, A.-L. BARABÁSI, Pág 74Av. Prof. Lucio Martins, Trav. 4, Bl. 18 - Cidade Universitária - 05508-900 - São Paulo - SP - Brasil

Telefones: (+55-11) 3091-6325 / 4925 Fax: (+55-11) 3815-3083www.futuro.usp.br - [email protected]

Coeficiente de Aglutinação

O coeficiente de aglutinação12 determina o quão próximo um grafo está de ser considerado um clique.

Um clique é um grafo em que dado quaisquer dois nós, existe uma aresta ligando eles, é um

exemplo clássico de clique13.

Figura 514 – Grafo

Chamemos de a quantidade de triângulos presentes no grafo G que tenham como um dos

vértices, ou seja é a quantidade de sub-grafos de G que possuam três arestas e três nós, sendo

um destes . Por sua vez, chamemos de a quantidade de sub-grafos de G que possuam duas

arestas e três nós, sendo um destes .

Logo, o coeficiente de aglutinação de , será:

Logo, considerando o grafo da Figura 3, teremos que o



Figura 6 – A esquerda os triângulos que possuem como vértice, e a direita as triplas

O coeficiente de aglutinação global do grafo por sua vez é dado por:

Enquanto nos grafos aleatórios coeficiente de aglutinação é dado por:

Onde é o grau médio do grafo e é número de nós, em Scale-free networks o coeficiente de

aglutinação aparentemente15 decai seguindo uma lei de potencia



Detalhes de ImplementaçãoPor que Drupal?O Drupal é um CMS/CMF open source feito em Drupal, sua arquitetura beneficia a implementação de

comunidades online, ele inclusive possui uma longa história de uso no governo brasileiro, especialmente

no Ministério da Cultura. Por isso optamos por desenvolvermos uma suíte de módulos para ele.

Modularização

Graph Module

O Graph Module é um módulo responsável por armazenar as informações dos grafos sociais e controlar

seu preenchimento e renderização. Um Grafo é um tipo de node do Drupal, integravel com CCK, Views

e outras ferramentas padrões do drupal, o que possibilita, por exemplo, que um grafo seja

georeferênciado, seja plotado num mapa, ou seja, atrelado ao período do tempo.

Ele também possui suporte a versionamento, o que significa que o conteúdo do grafo (nós e arestas)

seja recalculado periodicamente, com as novas informações sendo salvas em revisões, possuindo assim

uma forma fácil de avaliar a evolução da rede.

Para isso, o Graph Module implementa a Graph API, a espinha dorsal da suíte, a ser descrita em

detalhes no próximo capítulo.

Graph API

A Graph API permite que módulos de terceiros implementem seus próprios algoritmos de

preenchimento, assim um mesmo grafo pode representar as relações de amizade dentro de uma

comunidade e a relevância das pessoas dentro dessa comunidade.

Uma hook implementando a Graph API é muito parecido com a hook Node API do Drupal, a seguir um

exemplo de implementação da hook:



function graph_graph($op, $a2 = '', $a3 = NULL) { switch($op) { case 'list': $algorithms = array( array( 'name' => 'static', 'title' => 'Static graph', ), ); return $algorithms; case 'form': $name = $a2; switch($name) { case 'static': $form['edges'] = array( '#type' => 'textarea', '#title'=> 'Edges', ); } return $form; case 'process': $algorithm = $a2['algorithm'];

switch($algorithm['name']) { case 'static': $data = $a2['edges']; $lines = explode("\n",$data); if(is_array($lines)) { foreach($lines as $line){ $foo = explode('->', $line); if(is_array($foo)) { $edges[] = array( 'from' => trim($foo[0]), 'to' => trim($foo[1]), 'orientation' => 0, ); } } } break;

} return $edges;

}}



Graph Rendering

Graph Rendering é a parte da suite responsável por representar graficamente os grafos. Ela foi desenvolvida em Flex, baseado na toolkit opensource Prefuse Flare.

Exemplo de Visualização gerada pelo Graph Rendering

O arquivo de entrada é um XML no formal GraphML, especificado em http://graphml.graphdrawing.org/specification/, um exemplo de arquivo GraphML é:

<?xml version="1.0" encoding="UTF-8"?><graphml>

<graph><key id="name" for="node" attr.name="name" attr.type="string" /><key id="gender" for="node" attr.name="gender" attr.type="string" />

<node id="a"><data key="name">a</data><data key="gender">M</data>

</node><node id="e">

<data key="gender">M</data><data key="name">e</data>

</node><node id="d">

<data key="gender">M</data><data key="name">d</data>

</node><node id="c">

<data key="gender">M</data>



http://graphml.graphdrawing.org/specification/

<data key="name">c</data></node><node id="b">

<data key="gender">M</data><data key="name">b</data>

</node><node id="f">

<data key="name">f</data><data key="gender">M</data>

</node>

<edge source="a" target="e" oriented="0" /><edge source="a" target="d" oriented="0" /><edge source="a" target="c" oriented="0" /><edge source="a" target="b" oriented="0" /><edge source="f" target="e" oriented="0" /><edge source="f" target="d" oriented="0" /><edge source="d" target="c" oriented="0" /><edge source="f" target="b" oriented="0" /><edge source="f" target="a" oriented="0" /><edge source="a" target="f" oriented="0" />

</graph></graphml>

Conclusão

Estudar Scale-free Networks nos permite modelar, e com isso compreender melhor e mais do que isso

prever o que acontece em várias redes reais. Numa sociedade extensivamente baseada na Internet

como a nossa, é de suma importância quais são suas vulnerabilidades e potencialidades, para que

possamos minimizar o impacto caso algum infortúnio venha acontecer. Vários estudos já forma feitos

nessa área, notavelmente o de L. Zhao, K. Park e Y.C. Lai., o Graph Module em específico nos ajuda

disponibilizando um jeito fácil de visualizar propriedades intrínsecas de comunidades online, obviamente

ainda temos um longo caminho a frente por ser percorrido. A maior parte das pendências se encontra na

ferramenta de renderização de grafos, mas conforme a lib em que nos baseados evolue esses erros

tendem a ser mitigados. No mais, talvez uma mudança de foco de um approach nas estruturas de dados

e nas funções da API seja recomendado. A API atual dá muito mais importância ao conceito de arestas

do que ao de nós, mas a experiência adquirida ao longo desse trabalho me diz que deveríamos partir

para estruturas mais voltadas aos nós e sua relevância na rede.



BibliografiaS. MILGRAM – The small world problem. Psychology. Today 2, 60-67, (1967)S. MILGRAM – Behavioral Study of Obedience. Journal of Abnormal and Social Psychology 67: 371–378. PMID 14049516 (1963).R. ALBERT, A.-L. BARABÁSI – Statistical mechanics of complex networks. Reviews of Modern Physics 74, 47-97 (2002).D. J. WATTS, S. STROGATZ – Collective dynamics of 'small-world' networks. Nature 393: 440–442. (1998).L. ZHAO, K. PARK, Y.C. LAI – Attack vulnerability of scale-free networks due to cascading breakdown. Physical Review E 70, 035101(R) (2004)Z. DEZSO, A.-L. BARABÁSI – Halting viruses in scale-free networks. Physical Review E 65, 055103(R) (2002)BARABÁSI, A-L – Linked ISBN 0-7382-0667-9 (2002)

Notas Pagina pra comprar os volumes http://www.springer.com/dal/home/birkhauser/historyofscience?SGWID=1-40295-2-121672-0 Copyright Wikipedia http://en.wikipedia.org/wiki/Image:Konigsberg_bridges.png “Can one walk across the seven bridges and never cross the same one twice?” http://www.math.dartmouth.edu/~euler/pages/E053.html Erdős Number Project http://www.oakland.edu/enp/Erdos0 Mais informações em http://en.wikipedia.org/wiki/Milgram_experiment ,e em http://content.apa.org/journals/abn/67/4/371 “Small world Experiment” Números retirados de http://www.isc.org/index.pl?/ops/ds/host-count-history.php Internet Service Provider “Rich get richer” Ver R. ALBERT, A.-L. BARABÁSI, Pág 74 Ver D. J. WATTS, S. STROGATZ também é famoso devido ao Teorema de não-planaridade de Kuratowski Copyright Wikipedia http://en.wikipedia.org/wiki/Image:Complete_graph_K5.svg Ver R. ALBERT, A.-L. BARABÁSI, Pág. 75

Ver Z. DEZSO, A.-L. BARABÁSI



http://en.wikipedia.org/wiki/Image:Complete_graph_K5.svg

http://www.isc.org/index.pl?/ops/ds/host-count-history.php

http://content.apa.org/journals/abn/67/4/371

http://en.wikipedia.org/wiki/Milgram_experiment

http://www.oakland.edu/enp/Erdos0

http://www.math.dartmouth.edu/~euler/pages/E053.html

http://en.wikipedia.org/wiki/Image:Konigsberg_bridges.png


Apêndice A – Código Fonte do Graph Module<?php//; $Id: $function graph_menu() { $items = array(); $items['node/%graph_menu/graphml'] = array( 'title' => 'GraphML', 'page callback' => 'graph_export_graphml', 'page arguments' => array(1), 'access callback' => 'node_access', 'access arguments' => array('view', 1), 'file' => 'graphml.inc', 'type' => MENU_CALLBACK, );

return $items;

}

function graph_menu_load($nid) { if (!is_numeric($nid)) { return FALSE; } $node = node_load($nid); if (!isset($node->type) || $node->type != 'graph') { return FALSE; } return $node;}

function graph_form(&$node) { $type = node_get_types('type', $node);

if ($type->has_title) { $form['title'] = array( '#type' => 'textfield', '#title' => check_plain($type->title_label), '#required' => TRUE, '#default_value' => $node->title, '#weight' => -5



); }

if ($type->has_body) { $form['body_field'] = node_body_field($node, $type->body_label, $type->min_word_count); } // Now we define the form elements specific to our node type. $form['graph'] = array( '#type' => 'fieldset', '#collapsible' => true, '#collapsed' => false, '#title' => t('Edges'), '#tree' => true, ); $algorithms = _graph_get_algorithms_list(); if(count($algorithms)) { $form['graph']['new'] = array( '#type' => 'select', '#title' => t('Auto-fill Algorithms'), '#options' => $algorithms, ); $form['graph']['add'] = array( '#type' => 'submit', '#value' => t('add'), ); } return $form;}

function graph_form_alter(&$form, $form_state, $form_id) { if($form_id != 'graph_node_form') return; if(count($form_state['storage']['graph']['algorithms'])) { foreach($form_state['storage']['graph']['algorithms'] as $key => $algorithm) { $fieldset = array(



'#type' => 'fieldset', '#collapsible' => true, '#collapsed' => false, '#title' => $algorithm['title'], '#tree' => true, ); $fieldset['algorithm'] = array( '#type' => 'value', '#value' => $algorithm, ); $form['graph']['algorithms'][$key] = array_merge($fieldset, module_invoke_all('graph', 'form', $algorithm['name'], $algorithm['conf'])); }

} $form['#submit'][] = 'graph_node_form_submit'; }

function graph_node_form_submit($form, &$form_state) { if($form_state['clicked_button']['#value'] == 'add' && !empty($form_state['values']['graph']['new'])) { $algorithm = _graph_get_algorithm($form_state['values']['graph']['new']); //if(!isset($algorithm['conf'])) // $algorithm['conf'] = array(); $algorithm['id'] = count($form_state['storage']['graph']['algorithms']); $form_state['storage']['graph']['algorithms'][] = $algorithm; } else { }}

function _graph_get_algorithm($id = NULL) { static $algorithms = NULL; if($algorithms == NULL) { $raw = module_invoke_all('graph','list'); foreach($raw as $algorithm) { $algorithms[$algorithm['name']] = $algorithm; } } if($id != NULL) { if(isset($algorithms[$id])) {



return $algorithms[$id]; } else { return NULL; } } return $algorithms;}

function _graph_get_algorithms_list() { $algorithms = _graph_get_algorithm(); foreach($algorithms as $key => $data) { $result[$key] = $data['title']; } return $result;}

function graph_graph($op, $a2 = '', $a3 = NULL) { switch($op) { case 'list': $algorithms = array( array( 'name' => 'static', 'title' => 'Static graph', ), array( 'name' => 'simple_user_content_relationship', 'title' => 'Simple User to User Relationship', ), ); return $algorithms; case 'form': $name = $a2; switch($name) { case 'static': $form['edges'] = array( '#type' => 'textarea', '#title'=> 'Edges', ); }



return $form; case 'process': $algorithm = $a2['algorithm'];

switch($algorithm['name']) { case 'static': $data = $a2['edges']; $lines = explode("\n",$data); if(is_array($lines)) { foreach($lines as $line){ $foo = explode('->', $line); if(is_array($foo)) { $edges[] = array( 'from' => trim($foo[0]), 'to' => trim($foo[1]), 'orientation' => 0, ); } } } break; case 'simple_user_content_relationship': $nodes = db_queryd("SELECT nid, title, uid FROM {node} WHERE type != 'graph'"); while($node = db_fetch_object($nodes)) { $poster = user_load($node->uid); $comments = db_queryd("SELECT cid, uid FROM {comments} WHERE nid = %d", $node->nid); while($comment = db_fetch_object($comments)) { if($comment->uid > 0) { $commenter = user_load($comment->uid); if($commenter->uid != $poster->uid) { $edges[] = array( 'from' => $commenter->name, 'to' => $poster->name, 'orientation' => 1, ); } } } }



break; } return $edges;

}}

function graph_validate(&$node) { if($node->op != 'add' && (!isset($node->graph['algorithms']) || count($node->graph['algorithms']) < 1)) { form_set_error('new',t('Each graph should have at least one Algorithm.')); }}

function graph_perm() { return array( 'create graph', 'delete own graph', 'delete any graph', 'edit own graph', 'edit any graph', );}

function graph_access($op, $node, $account) { if ($op == 'create') { return user_access('create graph', $account); }

if ($op == 'update') { if (user_access('edit any graph', $account) || (user_access('edit own graphs', $account) && ($account->uid == $node->uid))) { return TRUE; } }

if ($op == 'delete') { if (user_access('delete any graph', $account) || (user_access('delete own graph', $account) && ($account->uid == $node->uid))) { return TRUE;



} }}

function graph_node_info() { return array( 'graph' => array(

'name' => t('Graph'), 'module' => 'graph', 'description' => t("This is an example node type with a few fields."),

'has_title' => TRUE, 'title_label' => t('Title'), 'has_body' => TRUE, 'body_label' => t('Description'),

));

}

function graph_load($node) { $additions['graph']['oriented'] = db_result(db_query("SELECT oriented FROM {graph} WHERE nid = %d",$node->nid)); $additions['graph']['edges'] = array(); $edges = db_query("SELECT àlgorithm`, `delta`, `from`, `to`, òrientation` FROM {graph_data} WHERE nid = %d AND vid = %d", $node->nid, $node->vid); while($edge = db_fetch_array($edges)) { $additions['graph']['edges'][] = $edge; if(!isset($additions['graph']['vertices'][$edge['from']])) _graph_create_vertice($additions['graph']['vertices'], $edge['from']); if(!isset($additions['graph']['vertices'][$edge['to']])) _graph_create_vertice($additions['graph']['vertices'], $edge['to']); } return $additions;}

function _graph_create_vertice(&$vertices, $id) { $vertice = array( 'id' => count($vertices), 'name' => $id, 'gender' => count($vertices)%2? 'M' : 'F', );



$vertices[$id] = $vertice; return $vertice;}

function graph_insert($node) { graph_rebuild_edges($node); //db_query("INSERT into {graph} (nid, oriented) VALUES (%d, %d)", $node->nid, $node->graph['oriented']);}

function graph_update($node) { // if this is a new node or we're adding a new revision,

//if ($node->revision) { graph_rebuild_edges($node); //}}

function graph_rebuild_edges($node) { foreach($node->graph['algorithms'] as $algorithm) { $edges = module_invoke_all('graph','process',$algorithm, $node); foreach($edges as $edge) { db_query("INSERT INTO {graph_data} (`nid`, `vid`, àlgorithm`, `delta`, `from`, `to`, òrientation`) VALUES (%d, %d, '%s', %d, '%s', '%s', %d)", $node->nid, $node->vid, $algorithm['algorithm']['name'], $algorithm['algorithm']['id'], $edge['from'], $edge['to'], $edge['orientation']); } }}

function graph_delete($node) { // Notice that we're matching all revision, by using the node's nid. db_query('DELETE FROM {graph_data} WHERE nid = %d', $node->nid);}

function graph_view($node, $teaser = FALSE, $page = FALSE) { $swf_path = base_path().drupal_get_path('module','graph').'/flare.graph.swf'; $swf_string = $swf_path.'?graphml_file='.url('node/'.$node->nid.'/graphml');



$flash_object = ' <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"

id="flare" width="600" height="600"

codebase="http://fpdownload.macromedia.com/get/flashplayer/current/swflash.cab">

<param name="movie" value="'.$swf_string.'" /><param name="quality" value="high" /><param name="bgcolor" value="#2e2e2e" /><param name="allowScriptAccess" value="sameDomain" /><embed src="'.$swf_string.'" quality="high" bgcolor="#2e2e2e"

width="600" height="600" name="explorer" align="middle"play="true"loop="false"quality="high"allowScriptAccess="sameDomain"type="application/x-shockwave-flash"pluginspage="http://www.adobe.com/go/getflashplayer">

</embed></object>';

$node = node_prepare($node, $teaser); $node->content['flare'] = array( '#value' => $flash_object, '#weight' => 1, );

return $node;}

function graph_export_graphml($node) { $output = new SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><graphml></graphml>');

$graph = $output->addChild('graph'); _add_key($graph,'name', 'node', 'string'); _add_key($graph,'gender', 'node', 'string'); foreach($node->graph['vertices'] as $vertice) { $v = $graph->addChild('node'); $v->addAttribute('id', $vertice['id']); foreach($vertice as $key => $value) {



if($key != 'id') { $a = $v->addChild('data',$value); $a->addAttribute('key',$key); } } } foreach($node->graph['edges'] as $edge) { $e = $graph->addChild('edge'); $e->addAttribute('source', $node->graph['vertices'][$edge['from']]['id']); $e->addAttribute('target', $node->graph['vertices'][$edge['to']]['id']); //$e->addAttribute('oriented', $edge['orientation']); } $xml = $output->asXML(); $xml = str_replace('"/><edge','"></edge><edge', $xml); $xml = str_replace('"/></graph>','"></edge></graph>', $xml); print($xml); //$domXML = dom_import_simplexml($output); die;}

function _add_key($graph, $name, $for, $type){ $key = $graph->addChild('key'); $key->addAttribute('id', $name); $key->addAttribute('for', $for); $key->addAttribute('attr.name', $name); $key->addAttribute('attr.type', $type);}



Apêndice B – Código fonte do Flex Graph Renderingpackage {

import flare.animate.Transitioner;import flare.data.DataSet;import flare.display.RectSprite;import flare.display.TextSprite;import flare.vis.Visualization;import flare.vis.data.Data;import flare.vis.data.NodeSprite;import flare.vis.operator.filter.GraphDistanceFilter;import flare.vis.operator.layout.RadialTreeLayout;

import flash.display.LoaderInfo;import flash.display.Sprite;import flash.events.MouseEvent;import flash.geom.Rectangle;import flash.text.TextFormat;

[SWF(width="600", height="600", backgroundColor="#2e2e2e", frameRate="30")]public class graph extends Sprite{

public var paramObj:Object; private var vis:Visualization;

private var maxLabelWidth:Number;private var maxLabelHeight:Number;

private var _gdf:GraphDistanceFilter;

private var _maxDistance:int = 2;

private var _transitionDuration:Number = 2;

public function graph() { try { paramObj = (this.root.loaderInfo as LoaderInfo).parameters; } catch (error:Error) { trace(error.toString()); }



var gmr:GraphMLReader = new GraphMLReader(onLoaded);gmr.read(paramObj.graphml_file);

}

private function onLoaded(data:Data):void {

vis = new Visualization(data);

var w:Number = stage.stageWidth;var h:Number = stage.stageHeight;

vis.bounds = new Rectangle(0, 0, w, h);

var textFormat:TextFormat = new TextFormat();textFormat.color = 0xffffffff;var i:int = 0;vis.data.nodes.visit(function(ns:NodeSprite):void {

var ts:TextSprite = new TextSprite(ns.data.name,textFormat);

ns.addChild(ts);});

vis.data.nodes.setProperty("x",w/2);vis.data.nodes.setProperty("y",h/2);

maxLabelWidth = getMaxTextLabelWidth();maxLabelHeight = getMaxTextLabelHeight();

vis.data.nodes.visit(function(ns:NodeSprite):void { var rs:RectSprite = new RectSprite( -maxLabelWidth/2-1,-

maxLabelHeight/2 - 1, maxLabelWidth + 2, maxLabelHeight + 2);if (ns.data.gender == "M") {

rs.fillColor = 0xff000044; rs.lineColor = 0xff000044;

} else {rs.fillColor = 0xffaa0000; rs.lineColor = 0xffaa0000;

}



rs.lineWidth = 2;

ns.addChildAt(rs, 0); // at postion 0 so that the text label is drawn above the rectangular box

ns.size = 0;adjustLabel(ns,maxLabelWidth,maxLabelHeight);

ns.mouseChildren = false;

ns.addEventListener(MouseEvent.CLICK, update);

ns.buttonMode = true;});

var lay:RadialTreeLayout = new RadialTreeLayout();lay.useNodeSize = false;

var root:NodeSprite = vis.data.nodes[0];

_gdf = new GraphDistanceFilter([root], _maxDistance,NodeSprite.GRAPH_LINKS);

vis.operators.add(_gdf); //distance filter has to be added before the layout

vis.operators.add(lay);

addChild(vis);

updateRoot(root);

}

private function update(event:MouseEvent):void {

var n:NodeSprite = event.target as NodeSprite;if (n == null) return; updateRoot(n);



}

private function updateRoot(n:NodeSprite):void {

vis.data.root = n;

_gdf.focusNodes = [n];

var t1:Transitioner = new Transitioner(_transitionDuration);

vis.update(t1).play();

}

private function getMaxTextLabelWidth() : Number {var maxLabelWidth:Number = 0;vis.data.nodes.visit(function(n:NodeSprite):void {

var w:Number = getTextLabelWidth(n);if (w > maxLabelWidth) {

maxLabelWidth = w;}

});return maxLabelWidth;

}

private function getMaxTextLabelHeight() : Number {var maxLabelHeight:Number = 0;vis.data.nodes.visit(function(n:NodeSprite):void {

var h:Number = getTextLabelHeight(n);if (h > maxLabelHeight) {

maxLabelHeight = h;}

});return maxLabelHeight;

}

private function getTextLabelWidth(s:NodeSprite) : Number {



var s2:TextSprite = s.getChildAt(s.numChildren-1) as TextSprite; // get the text sprite belonging to this node sprite

var b:Rectangle = s2.getBounds(s);return s2.width;

}

private function getTextLabelHeight(s:NodeSprite) : Number {var s2:TextSprite = s.getChildAt(s.numChildren-1) as

TextSprite; // get the text sprite belonging to this node spritevar b:Rectangle = s2.getBounds(s);return s2.height;

}

private function adjustLabel(s:NodeSprite, w:Number, h:Number) : void {

var s2:TextSprite = s.getChildAt(s.numChildren-1) as TextSprite; // get the text sprite belonging to this node sprite

s2.horizontalAnchor = TextSprite.CENTER;s2.verticalAnchor = TextSprite.CENTER;

}

}

}/** * simple graphml reader utility * */

import flare.data.converters.GraphMLConverter;import flare.data.DataSet;import flash.events.*;import flash.net.*;import flare.vis.data.Data;

class GraphMLReader {public var onComplete:Function;



public function GraphMLReader(onComplete:Function=null,file:String = null) { this.onComplete = onComplete;

if(file != null) {read(file);

} }

public function read(file:String):void {if ( file != null) {

var loader:URLLoader = new URLLoader();configureListeners(loader);var request:URLRequest = new URLRequest(file);try {

loader.load(request);} catch (error:Error) {

trace("Unable to load requested document.");

}}

}

private function configureListeners(dispatcher:IEventDispatcher):void { dispatcher.addEventListener(Event.COMPLETE, completeHandler); dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); }

private function completeHandler(event:Event):void {

if (onComplete != null) {var loader:URLLoader = event.target as URLLoader;var dataSet:DataSet = new GraphMLConverter().parse(new

XML(loader.data));onComplete(Data.fromDataSet(dataSet));

} else {trace("No onComplete function specified.");

}



}

private function securityErrorHandler(event:SecurityErrorEvent):void { trace("securityErrorHandler: " + event); }

private function ioErrorHandler(event:IOErrorEvent):void { trace("ioErrorHandler: " + event); } }

4 http://www.math.dartmouth.edu/~euler/pages/E053.html 5 Erdős Number Project http://www.oakland.edu/enp/Erdos0 8 Números retirados de http://www.isc.org/index.pl?/ops/ds/host-count-history.php 9 Internet Service Provider10 “Rich get richer”12 Ver D. J. WATTS, S. STROGATZ13 também é famoso devido ao Teorema de não-planaridade de Kuratowski14 Copyright Wikipedia http://en.wikipedia.org/wiki/Image:Complete_graph_K5.svg 15 Ver R. ALBERT, A.-L. BARABÁSI, Pág. 75



http://en.wikipedia.org/wiki/Image:Complete_graph_K5.svg

http://www.isc.org/index.pl?/ops/ds/host-count-history.php

http://www.oakland.edu/enp/Erdos0

http://www.math.dartmouth.edu/~euler/pages/E053.html

Education

Observatório da Cultura Digital - Conexões Científicas 2009: Análise de padrões de conectividade