Life ⚓️

The calculus of chess, for all its complexity, is ultimately constrained by its deterministic nature. Each move is played with perfect information, and every piece follows strict rules. War, by contrast, unfolds in a world of incomplete information, deception, and emergent chaos. This distinction bears directly on the question of optimizing ecological cost functions or increasing efficiency, because the two frameworks approach optimization from fundamentally different standpoints.

Chess is an exercise in minimizing loss and maximizing positional advantage within a defined space. It is a game of resource allocation—each piece has a specific role, and every move is calculated to increase efficiency within the scope of victory conditions. But it is also highly constrained. There is no room for genuine adaptation in the way a living system—or a war—requires. The entire game is a closed system of energy and position, with an optimal path that, in theory, could be precomputed given infinite processing power. In this sense, chess is an efficient game, but not an evolutionary one. It rewards efficiency within fixed parameters but does not optimize dynamically against an unpredictable environment.

War, on the other hand, is an open system. It does not merely allocate resources within a given framework; it defines and redefines its own framework continuously. War is less about playing within an existing structure than about shaping the very ground on which the game is played. This is why ecological optimization—if we consider ecology not just in the environmental sense, but in the broader sense of balancing resources, energy, and survivability—is far more likely to emerge in war than in chess. War, as an adaptive system, forces its participants to economize, to innovate, to find the path of least resistance not within a given set of rules but within a shifting, often hostile terrain.

In Apocalypse Now, Colonel Kurtz embodies the brutal calculus of ecological efficiency in war. He recognizes that conventional military logic, with its bureaucratic constraints and moral hesitations, is ultimately inefficient. The Viet Cong, by contrast, have adapted completely to their environment. They fight with ruthless efficiency, not through sheer force but through an absolute willingness to integrate their war effort into the landscape itself. They optimize their cost function by becoming part of the terrain, by leveraging every advantage nature provides, by fighting not just battles but entire ways of thinking. Kurtz understands this at a profound level. His horror is not just at the brutality of war, but at its cold logic—those who can commit to it absolutely, who can discard inefficiency in the form of hesitation, sentimentality, or morality, are the ones who will win.

This is why war, not chess, is the more likely domain for ecological optimization. Chess may be efficient, but it is brittle—it cannot adapt beyond its board, its rules, its predetermined paths. War, by contrast, is fluid. It is the process of continual reweighting, where the only constant is the imperative to survive and dominate. The Viet Cong cut off the arms of vaccinated children not out of sheer cruelty, but because they understood that terror is an efficient weapon. It rewires the enemy’s psychology, demoralizes their efforts, and does so with minimal expenditure of resources. This is not a chess move. It is something deeper, more horrifying—an act of total ecological integration, a ruthless pruning of inefficiency.

Chess, for all its beauty, cannot teach this kind of efficiency. It can only refine the existing rules. War, in its most brutal and unsentimental form, reshapes the rules entirely. That is why optimizing ecological cost functions—whether in military strategy, biological systems, or even economic competition—is far more likely to emerge from the logic of war than from the closed, predictable calculus of chess.

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': ['Ionian', 'Lydian', 'Phrygian', 'Dorian', 'Locrian', 'Aeolian', ], # Veni; 95/5
        'Mode': ['Mixolydian'], # Vidi; 80/20
        'Agent': ['♯5', '♭♭7'], # Vici; Veni; 51/49
        'Space': ['13th', '11th', '9th'], # Vidi; 20/80
        'Time': ['♭13', '♯11',  '♯9', '♭9', '7th'] # Vici; 5/95
    }

# Assign colors to nodes
def assign_colors():
    color_map = {
        'yellow': ['Mixolydian'],  
        'paleturquoise': ['Aeolian', '♭♭7', '9th', '7th'],  
        'lightgreen': ['Locrian', '11th', '♭9', '♯9', '♯11'],  
        'lightsalmon': [
            'Phrygian', 'Dorian', '♯5',  
            '13th', '♭13'
        ],
    }
    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("Veni, Vidi, Vici", fontsize=15)
    plt.show()

# Run the visualization
visualize_nn()

Fig. 4 How now, how now? What say the citizens? Now, by the holy mother of our Lord, The citizens are mum, say not a word. Indeed, indeed. When Hercule Poirot predicts the murderer at the end of Death on the Nile, he is, in essence, predicting the “next word” given all the preceding text (a cadence). This mirrors what ChatGPT was trained to do. If the massive combinatorial search space—the compression—of vast textual data allows for such a prediction, then language itself, the accumulated symbols of humanity from the dawn of time, serves as a map of our collective trials and errors. By retracing these pathways through the labyrinth of history in compressed time—instantly—we achieve intelligence and “world knowledge.” Inherited efficiencies are locked in data and awaiting someone “ukubona” the lowest ecological cost by which to navigate lifes labyrinth. But a little error and random chaos must be added to go just little beyond the wisdom of our forebears, since the world isn’t static and we must adapt to it. In biology, mutations are such errors added to the “wisdom” of our forebears encoded in DNA. Life’s final cadence, as suggested most articulately by Dante – inferno, limbo, paradiso – is merely a side effect of optimizing the ecological cost function. Unlike what Victorian moralists, including Dante to an extent, think: the final cadence isn’t everything.