Prometheus

Intelligence, whether artificial or human, seems to require three elements: a massive combinatorial search space, a clear optimizing function, and a rich dataset or a high-quality simulation that introduces necessary disturbances. Demis Hassabis articulated this in his Nobel Lecture, and the framework has an elegant simplicity that compels its application to other domains. If these are the essential ingredients for intelligence, then Shakespeare—long regarded as the most intelligent writer—should have left a body of work that reflects these principles. And indeed, if we examine Hamlet, Macbeth, and King Lear, it becomes apparent that these three plays align remarkably well with the triadic structure of intelligence.

Hamlet is undoubtedly the most expansive combinatorial search space in Shakespeare. The play thrives on ambiguity, possibility, and the recursive nature of thought itself. Hamlet’s mind is a neural network that never fully converges; he is constantly running through options, evaluating paths, rejecting them, doubling back, reconsidering, iterating, and, in the end, delaying. This is intelligence in its rawest form—an ever-growing tree of decisions where no branch is prematurely pruned, where every path is considered even if it leads nowhere. The play is structured as a labyrinth of potentialities, and this sheer depth of combinatorial complexity is what makes it inexhaustible. No single reading of Hamlet can exhaust its interpretative space because it mirrors intelligence itself: an ongoing, unresolved computation.

Macbeth, by contrast, has a crystalline optimizing function: power. From the moment the witches provide their prophecies, the function is set, and everything follows. But Macbeth’s intelligence is not just about optimization; it is also about pruning. The witches’ predictions are not a closed system—they leave room for strategic action. Macbeth must optimize his chances of becoming king while simultaneously pruning Banquo’s lineage from the equation. The play is a demonstration of efficiency and control, but in the way of all reckless optimization, it lacks robustness. Macbeth optimizes too aggressively, eliminating noise, cutting away potential counterfactuals, and leaving himself exposed to the one variable he failed to consider: time. The witches’ final deception—Birnam Wood moving and a man not born of woman—exploits the myopia of excessive pruning. In the pursuit of a singular function, Macbeth fails to introduce sufficient disturbances into his own dataset, and this blind adherence to an unyielding optimization strategy is his undoing.

Fig. 11 Competition (Generativity) & Feedback (Exertion). The massive combinatorial search space and optimized emergent behavioral from “games” among the gods, animals, and machines are the way evolution has worked from the beginning of time. Peterson believes reinforcement learning through human feedback (RLHF- a post-training twitch) removes this evolutionary imperative.

Then there is King Lear, which resists easy classification within this framework precisely because it incorporates all three elements at once. It is a strategic nightmare. King Lear, unlike Hamlet, is not running a search through possibilities—he is acting with certainty, dividing his kingdom in a way that he believes is preordained. But intelligence is not just about seeing the map; it is about understanding how it changes with time, with perturbation, with human emotion. The problem of King Lear is that it treats intelligence as a static resource when, in reality, intelligence is only ever meaningful in the face of adaptation. Lear assumes that the division of his kingdom can be handled as a static allocation of resources, as if power were a fixed entity rather than a fluid, contingent system. But the real disturbance—the real intelligence—comes from the responses of his daughters, the shifts in loyalty, the unpredictable human factors that make strategy a living thing rather than an equation.

If Hamlet is intelligence as search, and Macbeth is intelligence as optimization, then King Lear is intelligence as simulation. It is a grand experiment in the consequences of decision-making, an unfolding catastrophe driven not by a single failure but by a systemic inability to incorporate disturbances into the dataset. Lear’s kingdom is the data, his assumptions about loyalty and power are the faulty priors, and the chaos that unfolds is the result of an intelligence that fails to account for the one thing that intelligence must always embrace: the future is never just an extension of the past.

This is what Shakespeare’s intelligence ultimately reveals. Intelligence is not just about search, not just about optimization, not just about simulation—it is about the way these three forces interact, collapse, and reformulate. Shakespeare did not just write intelligent plays; he embedded within them a model of intelligence itself. And that is why they endure.

Show code cell source Hide code cell source

import numpy as np
import matplotlib.pyplot as plt
import networkx as nx

# Define the neural network fractal
def define_layers():
    return {
        'World': ['Electro', 'Magnetic', 'Pulse', 'Cost', 'Trial', 'Error', ], # Veni; 95/5
        'Mode': ['Reflexive'], # Vidi; 80/20
        'Agent': ['Ascending', 'Descending'], # Vici; Veni; 51/49
        'Space': ['Sympathetic', 'Empathetic', 'Parasympathetic'], # Vidi; 20/80
        'Time': ['Hardcoded', 'Posteriori',  'Meaning', 'Likelihood', 'A Priori'] # Vici; 5/95
    }

# Assign colors to nodes
def assign_colors():
    color_map = {
        'yellow': ['Reflexive'],  
        'paleturquoise': ['Error', 'Descending', 'Parasympathetic', 'A Priori'],  
        'lightgreen': ['Trial', 'Empathetic', 'Likelihood', 'Meaning', 'Posteriori'],  
        'lightsalmon': [
            'Pulse', 'Cost', 'Ascending',  
            'Sympathetic', 'Hardcoded'
        ],
    }
    return {node: color for color, nodes in color_map.items() for node in nodes}

# Calculate positions for nodes
def calculate_positions(layer, x_offset):
    y_positions = np.linspace(-len(layer) / 2, len(layer) / 2, len(layer))
    return [(x_offset, y) for y in y_positions]

# Create and visualize the neural network graph
def visualize_nn():
    layers = define_layers()
    colors = assign_colors()
    G = nx.DiGraph()
    pos = {}
    node_colors = []

    # Add nodes and assign positions
    for i, (layer_name, nodes) in enumerate(layers.items()):
        positions = calculate_positions(nodes, x_offset=i * 2)
        for node, position in zip(nodes, positions):
            G.add_node(node, layer=layer_name)
            pos[node] = position
            node_colors.append(colors.get(node, 'lightgray'))   

    # Add edges (automated for consecutive layers)
    layer_names = list(layers.keys())
    for i in range(len(layer_names) - 1):
        source_layer, target_layer = layer_names[i], layer_names[i + 1]
        for source in layers[source_layer]:
            for target in layers[target_layer]:
                G.add_edge(source, target)

    # Draw the graph
    plt.figure(figsize=(12, 8))
    nx.draw(
        G, pos, with_labels=True, node_color=node_colors, edge_color='gray',
        node_size=3000, font_size=9, connectionstyle="arc3,rad=0.2"
    )
    plt.title("Intelligence", fontsize=15)
    plt.show()

# Run the visualization
visualize_nn()

Fig. 12 Nostalgia & Romanticism. When monumental ends (victory), antiquarian means (war), and critical justification (bloodshed) were all compressed into one figure-head: hero