Veiled Resentment

Deception and strategy are often conflated, but their distinction lies in the fundamental nature of their engagement with an adversary. Deception is static; it thrives on concealment, on the fixed nature of what is hidden. Strategy, by contrast, is dynamic; it necessitates an ongoing recalibration in response to the fluidity of an opponent’s moves. This distinction is not merely semantic—it is the dividing line between games of incomplete information and the relentless flux of open competition.

Consider poker. A player’s hand, once dealt, is immutable. The cards do not shift mid-game; the hidden elements of the game are locked from the outset. What matters is the perception of those cards, the ability to bluff, mislead, and induce an opponent to make incorrect inferences. Deception in this context is an optimization problem—finding the most effective way to misrepresent a fixed reality. Once the hand is revealed, the deception is either validated or shattered, but it does not evolve during the course of play. The player is playing with a constant, a frozen variable that can only be obscured or disclosed. This is the nature of deception: the manipulation of what is already known to oneself but unknown to others.

Fig. 24 Inheritence, Heir, Brand, Tribe, Religion. We’ve described these stages of societal history. We’re discussing brand: an agent exerts an ecological loss function that some consider “creative destruction”.

Contrast this with Formula One racing. A driver like Lewis Hamilton is not engaged in deception; he is engaged in strategy. The race itself is a cascade of variables, a landscape in constant motion. The road conditions change, tire wear evolves, fuel levels deplete, weather patterns shift, and—most importantly—other drivers are not fixed entities. They are adjusting, learning, countering. A great driver does not rely on a single, concealed advantage; he adapts, recalibrates his lines, adjusts braking points, modifies his aggression based on real-time inputs. His adversary is not a passive observer attempting to decode a hidden hand—his adversary is a thinking, responding force, dynamically reshaping the contest. Strategy, in this case, is a dance of mutual adaptation, where success depends on the ability to read and react to the ever-changing terrain of competition.

The same holds true in horse racing. A jockey does not merely have a singular game plan from the outset, immutable and fixed. The movement of other horses, the energy of the pack, the condition of the track—all of these demand adjustments. The great jockey senses the shifting landscape and reacts, deciding in fractions of a second whether to hold back, push forward, or switch lanes. Here, knowledge is not something to be hidden, as in poker, but something to be updated continuously. The adversary is not just a static threat but a force of movement and intention, making strategy a necessarily fluid endeavor.

This distinction between deception and strategy extends beyond these domains. In warfare, deception may involve planting false intelligence, creating the illusion of a troop buildup, or disguising one’s true strength. But true strategy requires something more: it demands maneuvering in response to an enemy’s evolving tactics, an understanding that what was true a moment ago may not hold in the next. A deceptive force can rely on a single masterstroke, a ruse to tip the balance in its favor, but a strategist must be prepared for the fact that the battlefield is alive, that the enemy is thinking, and that no static trick will sustain victory.

The key takeaway is this: deception exploits the fixed, while strategy embraces the fluid. A deceiver leans on what is static, on the advantage of asymmetrical knowledge that exists in a frozen state. A strategist, by contrast, operates in the realm of dynamism, where the battle is not about what is hidden but about what is evolving. The great mind in strategy does not merely control what the opponent sees—it controls how the game unfolds by understanding that the game itself is never still.

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': ['Cosmos', 'Externalities', "Trump", 'Value on Book', 'Trial', 'Error', ],  
        'Mode': ['Index of Market'],  
        'Agent': ['Brand Name', 'Conservative'],  
        'Space': ['Weaponize', 'Tokenize', 'Intellectual Property'],  
        'Time': ["Masculinity", 'Frontiers',  'Return-on-Investment', 'Civilization', 'Diversity']  
    }

# Assign colors to nodes
def assign_colors():
    color_map = {
        'yellow': ['Index of Market'],  
        'paleturquoise': ['Error', 'Conservative', 'Intellectual Property', 'Diversity'],  
        'lightgreen': ['Trial', 'Tokenize', 'Frontiers', 'Return-on-Investment', 'Civilization'],  
        'lightsalmon': [
            "Trump", 'Value on Book', 'Brand Name',  
            'Weaponize', "Masculinity"
        ],
    }
    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("Woza Ubone Ikristu, Umpherekezana", fontsize=15)
    plt.show()

# Run the visualization
visualize_nn()

Fig. 25 Vet Advised When to Sell Horse. Right after an outstanding performance. Because you want to control how its perceived, the narrative backstory, and how its future performance might be imputed. Otherwise, reality manifests with point and interval estimates. This is the subject matter of the opening dialogue in Miller’s Crossing.