A general framework for complex networks Mark Changizi Sloan-Swartz Center for Theoretical Neuroscience Caltech

Taxonomy ?

(1)Behavioral complexity (2)Structural complexity (3)Connectivity (4)Parcellation Four parts to the talk

Part 1 Building behaviors

Nodes and edges not shown Structures in the network etc Behaviors of the network Behaviors are built out of combinations of structures

Examples

Universal language approach Invariant-length approach ? How is behavioral repertoire size increased?

y = x R 2 = Log number of song types Log number of syllable types Bird vocalization structural repertoire versus behavioral repertoire Mammalian behavior None are universal languages. I.e., none are flat. Instead, behavior length is invariant. Log number of buttons y = 0.114x R 2 = Log length of manual Calculators y = 0.631x R 2 = Log length of manual Televisions y = x R 2 = Log length of manual CD players y = x R 2 = Log length of manual VCRs Electronic user-interface languages Changizi, 2001, 2002, 2003 Genes and cell types

Computer software also tends to have invariant length behaviors, since programs must run within a feasible amount of time. Instead of allowing running time to increase, programmers increase the number of instructions, or lines of code, in the program. [This is why, for example, quicksort has more lines of code than bubblesort.] Computer software too

Part 2 Building structures

Nodes and edges not shownEdges not shown...is actually... Structures are built out of combinations of nodes

Examples

Universal language approach Invariant-length approach ? How is structure repertoire size increased?

None are universal languages. Instead, structure length is invariant. (Also true in competitive networks) Neocortex: Networks of neurons Ant colonies: Networks of ants Organisms: Networks of cells Circuits: Networks of electronic components Universities: Networks of faculty Legos: Networks of connectable pieces Changiz et al., 2002 # node types versus network size

Neocortex: # neuron types versus brain size Brains thus appear to have invariant length structures Cortical modules, barrels...: Number of neurons across versus network size Invariant-length structures: Minicolumns and modules (below) # neuron types increases in larger nervous networks: neocortex and retina Retina: # neuron types versus brain size

Computer software also has invariant length structures Invariant-length structures: Lines of code # operator types increases in larger programs: Lines of code versus program size # operator types versus program size

Part 3 Connectivity and network diameter for behaviors

Behavior is combinatorial, and thus the structures must all be “close”. And this can only be accomplished via edges, and edges are between nodes. Edges not shown...is actually... Keeping structures “close” with edges

Examples

 =2 * * * * *  For behavioral networks, expect... network diameter  1/v, for N . Payoff:  scales up very slowly, saving wire. Cost: Behaviors are longer (roughly v times longer).  ~N 1  1  ~N 1/2  2  invariant  How is node-degree increased? Behavior not redundant, but wire too costly Wire cost low, but diameter too high and thus behavior increasingly redundant

Electronic circuits N ~ V gray 2/3 N syn ~ V gray 1 Neocortex    How electronic circuits and neocortex scale

Some other consequences of a node-degree increase Node density decreases - neocortex:  ~V gray -1/3. - circuits Wires (and somas) thicken - neocortex: R~V gray 1/9 - circuits White matter disproportionately increases - neocortex: V wh ~V gray 4/3 [disproportionate due to wire thickening]

Also… node-degree increases in larger software

Part 4 Parcellation

The partition problem Broadly expect that # partitions scales up disproportionately slowly as network size increases

Theory for neocortex total # area-edges ~ A 2 Well-connectedness

Economical well-connectedness implies … # areas ~ N 1/2 area degree ~ N 1/2

Parcellation also increases disproportionately slowly in other behavioral networks y = x R 2 = log N log # modules n=77 # program modules vs program size Computer software # divisions vs # employees Businesses Probably electronic circuits too (partition problem)

Conclusions

Summary 1. Invariant-length structures 2. Invariant-length behaviors 3. Invariant network diameter (via slow increase in degree) 4. Parcellation increases 1. Invariant-length structures 1. Invariant-length structures ?

? short partition(MATRIXELREC edgelist[MATNUM], int p, int r) { float pivot; short i, j; MATRIXELREC temp; pivot=edgelist[p].weight; i=p-1; j=r+1; while (i<j) { do j--; while (edgelist[j].weight > pivot); do i++; while (edgelist[i].weight < pivot); if (i<j) { temp=edgelist[j]; edgelist[j]=edgelist[i]; edgelist[i]=temp; } else return j; } void quickedgesort(MATRIXELREC edgelist[MATNUM], int p, int r) { int q; if (p<r) { q=partition(edgelist,p,r); quickedgesort(edgelist,p,q); quickedgesort(edgelist,q+1,r); } Software code, carved at its joints temp; r} else r return j; while partition } q } quickedgesort( MATRIXELREC (edgelist[MATNUM], p, int r) { float; short i, j; temp; pivot=edgelist[p].weight; j i=p-1; j=r+1; int = (i<j) { do j--; quickedgesort edgelist pivot i while MATRIXELREC (edgelist[j].weight >); void do; while (edgelist[i].weight < pivot); great if (i<) pivot r {temp= edgelist[j]; =edgelist[i]; ++ edgelist[i]=<) { q partition(, p,r); short (edgelist,p,); (edgelist,q+,); }} quickedgesort 1 edgelist[MATNUM], int p, MATRIXELREC edgelist[j] int r) { int q; if (p Same software code, but with nodes scrambled The long-term grand goal: The ability to parse complex networks so as to reveal their underlying program.