Risk

Appendix: Classifying Adversarial Games and the Immutable Laws of Odds

See also

Failure

La Régle, DQM

In the realm of trial and error, games can be classified based on whether learning can compress or collapse odds, shaping outcomes in ways that reflect the dynamic or static nature of the systems they represent. Some games, like roulette, coin tosses, and dice rolls, operate under immutable laws of probability. These are the purest forms of static games—no amount of repetition, instinct, or pattern recognition alters their odds. The learning network, no matter how sophisticated, cannot impact these systems because they are governed by strict mathematical principles. The inability to compress odds here reflects the fundamental rules of the universe, a reminder of boundaries that human ingenuity and neural networks cannot breach.

Illusion, G1 & G2

In contrast, there are games like poker, where pattern recognition, instinct, and psychological acuity introduce an element of learning. These games are high-risk and error-prone, but they allow for some compression of odds as players refine their skills. The adversarial nature of poker is unique because it blends raw instinct—reading a bead of sweat or a twitch—with strategy and the capacity to anticipate opponents’ actions. However, this learning is bounded; no amount of pattern recognition can fully predict outcomes in poker because the human element introduces randomness. The adversarial tension lies in balancing instinct with the ability to suppress or manipulate it, making poker a metaphor for high-stakes social dynamics.

Ancién, Nouveau

Moving further, we encounter games like horse racing, sports betting, and other wagers where incomplete information dominates. Here, the adversarial challenge extends beyond instincts to include data collection and analysis. Understanding the pedigree of a horse, the condition of a jockey, or the training of an athlete offers a semblance of learning, but the complexity of these systems makes true mastery elusive. The volatility of such environments—new competitors, shifting conditions, and the sheer volume of unknowns—prevents comprehensive compression of odds. These games are a reminder of the constraints imposed by time and information asymmetry, where even the most diligent players remain at the mercy of change.

Du Jeu, G3

At the apex of adversarial systems lie those that involve direct human competition in structured environments, such as corporate rivalries or professional sports. These systems are highly dynamic, allowing for significant learning and adaptation over time. Companies, for instance, employ trial and error to refine strategies, often leading to the consolidation of power in oligarchic structures. This process blurs the line between adversarial and cooperative equilibria, as competitors form cartels to restrict market access or establish informal agreements to limit poaching. In American sports leagues like the NFL or NBA, the cartel-like restrictions on teams create controlled adversarial environments, while European leagues, with promotion and relegation, retain a more anarchic and dynamic adversarial quality. These games demonstrate how learning can not only collapse odds but also reshape the rules of engagement.

Grande, ACh

Beyond these structured systems, adversarial games bleed into social phenomena, such as modern romantic dynamics. Consider the Gen Z engagement, where proposals have evolved into high-stakes performances optimized for Instagram content. What was once a collapsed process—engagement almost guaranteeing a wedding—has become as volatile as poker. The immediate instinctual gratification of a lavish proposal, complete with balloons and flowers, often dissipates without translating into a wedding. The focus shifts from long-term outcomes to ephemeral validation, reflecting a broader societal shift toward high-risk, high-reward interactions. This dynamic mirrors the adversarial nature of incomplete information systems, where pattern recognition (in this case, social media clout) drives decision-making at the expense of stability. A generation prioritizing click-bait is one divorced from the embodiment of pleasure

Fig. 13 Danse Macabre. Machine learning was already putting pianists out of a job in 1939. Our dear pianists looks completely flabbergasted. Not only has she been displaced, even if she were given the chance, she wouldn’t be able to play with four hands, as demanded by this piano transcription of Saint-Saëns masterpiece.

Ultimately, these classifications reveal a spectrum of adversarial systems, from the static and immutable to the dynamic and learnable. They highlight the interplay between rules, instincts, and learning, offering a framework to understand not only games but also broader human behaviors and societal trends. The inability to compress odds in static games reminds us of our limitations, while the volatility of dynamic systems challenges us to navigate complexity with ingenuity. In adversarial settings, from poker tables to Gen Z engagements, the art of compression becomes a metaphor for survival, adaptation, and the ceaseless negotiation of meaning.

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 structure
def define_layers():
    return {
        'World': ['Cosmos', 'Earth', 'Life', 'Cost', 'Parallel', 'Inheritence'],
        'Framework': ['Cosmology', 'Geology', 'Biology', 'Agency', 'Space', 'Time'],
        'Meta': ['Divine', 'Red Queen', 'Machine'],
        'Perception': ['Perception'],
        'Agency': ['Digital-Twin', 'Enterprise'],
        'Generativity': ['Parasitism', 'Mutualism', 'Commensalism'],
        'Physicality': ['Offense', 'Lethality', 'Retreat', 'Immunity', 'Defense']
    }

# Assign colors to nodes
def assign_colors():
    color_map = {
        'yellow': ['Perception'],
        'paleturquoise': ['Inheritence', 'Time', 'Enterprise', 'Commensalism', 'Defense'],
        'lightgreen': ['Parallel', 'Machine', 'Mutualism', 'Immunity', 'Retreat', 'Lethality', 'Space'],
        'lightsalmon': [
            'Cost', 'Life', 'Digital-Twin',
            'Parasitism', 'Offense', 'Agency', 'Biology', 'Red Queen'
        ],
    }
    return {node: color for color, nodes in color_map.items() for node in nodes}

# Define allowed connections between layers
def define_connections():
    return {
        'World': {
            'Cosmos': ['Cosmology', 'Geology', 'Biology'],
            'Earth': ['Geology', 'Biology', 'Agency', 'Space', 'Time'],
            'Life': ['Biology', 'Agency'],
            'Cost': ['Agency', 'Inheritence', 'Space', 'Time'],
            'Parallel': ['Space', 'Inheritence', 'Time'],
            'Inheritence': ['Time', 'Machine', 'Space', 'Agency']
        },
        'Framework': {
            'Cosmology': ['Divine', 'Red Queen'],
            'Geology': ['Red Queen', 'Machine'],
            'Biology': ['Machine', 'Agency', 'Red Queen'],
            'Agency': ['Divine', 'Red Queen', 'Machine'],
            'Space': ['Divine', 'Machine'],
            'Time': ['Machine', 'Red Queen']
        },
        'Meta': {
            'Divine': ['Perception'],
            'Red Queen': ['Perception'],
            'Machine': ['Perception']
        },
        # Other layers default to fully connected if not specified
    }

# 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()
    connections = define_connections()
    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'))  # Default color fallback

    # Add edges based on controlled connections
    layer_names = list(layers.keys())
    for i in range(len(layer_names) - 1):
        source_layer, target_layer = layer_names[i], layer_names[i + 1]
        if source_layer in connections:
            for source, targets in connections[source_layer].items():
                for target in targets:
                    if target in layers[target_layer]:
                        G.add_edge(source, target)
        else:  # Fully connect layers without specific connection rules
            for source in layers[source_layer]:
                for target in layers[target_layer]:
                    G.add_edge(source, target)

    # Ensure node_colors matches the number of nodes in the graph
    node_colors = [colors.get(node, 'lightgray') for node in G.nodes]

    # Draw the graph
    plt.figure(figsize=(14, 10))
    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("Deep Neural Network", fontsize=15)
    plt.show()

# Run the visualization
visualize_nn()

Fig. 14 Change of Guards. In Grand Illusion, Renoir was dealing the final blow to the Ancién Régime. And in Rules of the Game, he was hinting at another change of guards, from agentic mankind to one in a mutualistic bind with machines (unsupervised pianos & supervised airplanes). How priscient!