Could a Computer Scientist Build a Brain?

Author: Zador
Affiliation: Cold Spring Harbor Laboratory
Contact: kerstje@cshl.edu

How does a biological system transform a single cell into a complex, wired brain using only the instructions encoded within a genome? To answer this, we can reframe the biological process as a rigorous engineering challenge.

The Engineering Goal: Create a program that a single cell can execute to autonomously construct a fully functional brain.

The Fundamental Constraints

For this program to be viable, it must adhere to two strict physical limits:

1. Storage: It must be compact enough to fit within a genome.
2. Latency: It must execute quickly enough to complete within the window of biological development.

A computer scientist—even one devoid of biological training—would immediately see why certain intuitive approaches fail. Specifically, the following strategies are computationally feasible at scale impossible:

• Storing a specific coordinate for every single synapse.
• Allowing axons to search for their targets via random, blind exploration.

Because of these scaling limits, the "correct" algorithmic solutions naturally converge toward the strategies that evolution has actually implemented. This suggests that the architecture of neural development is not merely a result of historical accident (contingency), but is driven by computational necessity.

While previous thought experiments suggested that biologists might struggle to understand a microprocessor or fix a radio, this perspective offers a more optimistic path: we may be able to reverse-engineer the brain's design by analyzing how a genome must specify it.

---

The Scaling Challenge

Imagine providing a programmer with a complete connectome (a wiring diagram) and asking them to write the code to build it. The constraints are:

• Instruction Set: $\approx 1 \text{ GB}$ (the size of a genome).
• Runtime: $\approx 1 \text{ year}$ (the developmental window).

The algorithm must be scalable across vastly different biological complexities:

The Adjacency Matrix Problem: The simplest way to encode connectivity is an adjacency matrix requiring $n^2$ bits.

• For C. elegans, $n^2$ is small enough to fit in the genome.
• For humans, $n^2$ would require a genome size far exceeding biological reality.

Therefore, larger brains must use a different, more compressed strategy.

---

Interdisciplinary Implications

This approach formalizes the genome as a set of instructions for construction rather than a static description of the final product—a view shared by pioneers like Turing, von Neumann, Waddington, and Brenner.

Why this matters:

• For Neuroscientists: It identifies which molecular mechanisms are "hard" computational requirements and which are flexible.
• For Theorists: It frames biological growth as a solution to a complex, unsolved computational problem.
• For AI/ML Researchers: Modern ML relies on massive weight matrices or enormous training sets. Biology, however, generates functional networks from compact descriptions. Studying this could lead to new AI algorithms.

---

Defining the "Developmental Program"

The programmer cannot manually place neurons or solder connections. Instead, the process is distributed and recursive.

The Programmer's Requirements:

• Load the instruction set into the initial zygote.
• Define the initial state of the cell.
• Ensure the program can run independently in every daughter cell.

The Execution Logic:

Each cell runs the same code and can only access local information:

1. Its own internal state.
2. Molecular signals from immediate neighbors.

def cell_behavior(internal_state, neighbor_signals):
    if should_divide(internal_state, neighbor_signals):
        divide()
    if should_migrate(internal_state, neighbor_signals):
        migrate_to_target()
    if should_wire(internal_state, neighbor_signals):
        extend_growth_cone()
        if target_reached():
            form_synapse()

The Mathematics of Scale

To understand the magnitude of the task, consider the human brain:

• Number of neurons: $n \approx 10^{10}$
• Average connections per neuron: $m \approx 10^4$
• Total connections: $n \times m \approx 10^{14}$

To describe how the cost of these operations grows as the brain size $n$ increases, we use Big-O notation, $O(f(n))$. This allows us to ignore constant factors and focus on the growth rate. For example, an $O(n^2)$ cost (like the adjacency matrix) becomes prohibitively expensive as $n$ reaches $10^{10}$.