Veiled Resentment

The scientific process is both dangerous and deeply human—it doesn’t just generate truth; it also generates fraud, delusions, and hallucinations. The very mechanisms that allow us to refine knowledge also allow us to deceive ourselves and others. What makes science powerful is its ability to self-correct over time, but that correction is often slow, sometimes taking decades to overturn a well-entrenched falsehood. Science, then, is not merely the pursuit of truth; it is a battlefield where the forces of reason struggle against the distortions produced by incentive structures, cognitive biases, and even outright manipulation.

Fraud in science is not an external aberration but emerges from within the very same process that produces legitimate discoveries. The scientific process operates on competition, funding, and reputation—all of which can be manipulated. Some fraud is deliberate, such as the fabrication of data or the falsification of results to secure grants or prestige. In an academic environment where careers depend on publishing novel findings, the temptation to manipulate results is ever-present. This is why fraudulent papers can survive peer review and circulate within the scientific community before eventually being debunked.

Fig. 23 The Next Time Your Horse is Behaving Well, Sell it. The numbers in private equity don’t add up because its very much like a betting in a horse race. Too many entrants and exits for anyone to have a reliable dataset with which to estimate odds for any horse-jokey vs. the others for quinella, trifecta, superfecta. The eternal recurrence of the same, as Nietzsche framed it, unfolds a cosmos devoid of beginning or end, an architecture where every output node circles back as input to an identical iteration, endlessly. In such a framework, the demand for moral purpose dissolves into absurdity. The cosmos, infinite in time and space, operates beyond binaries of good and evil, refusing to submit its vastness to human conceits of narrative closure. Yet Goethe’s defiance of moral demands, while celebrating the autonomy of the artist, rings hollow when confronted with the persistent itch for a conclusion, as Anthony Capella’s narrator discovers. To demand purpose from art, perhaps, is not to ruin it, but to humanize it, to tether infinite loops of meaning to a finite self yearning for understanding. In rejecting moral purpose, we may resist simplifying complexity, but we also risk severing art from its audience—an audience that, like Capella’s Victorian memoirist, craves resolution, even if only to satisfy itself. And so, while Nietzsche’s cosmos tumbles through its eternal recurrence, it must tolerate those who insist on finding lessons, a phenomenon less a contradiction than an inevitable consequence of human architecture mirroring the infinite. What have we learned? Perhaps only that the output of one iteration can be both conclusion and renewal, endlessly oscillating between the finite and the infinite.

Yet, fraud is not always malicious. Science also suffers from a more insidious problem: self-deception. Pathological science occurs when researchers believe in their results so strongly that they ignore disconfirming evidence. Cold fusion, N-rays, and a host of other discredited theories were once championed by well-meaning scientists who unknowingly led their fields astray. The problem is compounded by mimicry—fraudulent research often mimics the structure of legitimate science, just as parasites evolve to resemble their hosts. Peer review, statistical analysis, and even the language of science can be weaponized, allowing falsehoods to masquerade as truth.

Beyond outright fraud, the scientific process also generates hallucinations and delusions at both individual and collective levels. Scientists, like all humans, are susceptible to cognitive biases, such as confirmation bias and motivated reasoning. These distortions can lead entire fields astray for years, as seen in psychology’s replication crisis or nutrition science’s decades-long war over dietary fat. Science is not immune to social contagion—consensus can form around ideas not because they are true but because they are institutionally or politically advantageous. Eugenics was once considered rigorous science, yet it was nothing more than a mass hallucination reinforced by ideology and institutional inertia.

False paradigms can persist for decades, misleading generations of scientists before finally being discarded. Phlogiston theory, caloric fluid, and Lamarckian inheritance were not frauds in the traditional sense, but they were systematic distortions of reality that shaped scientific understanding for years. These examples reveal an unsettling truth: the scientific process does not just produce knowledge; it also produces illusions. The challenge is distinguishing between them, and history suggests that even the best scientists struggle to do so in real-time.

In this sense, science is neither inherently good nor bad—it is a neutral, algorithmic process that generates both knowledge and illusion. The process refines truth through falsification and correction, but it also generates fraud when incentives are misaligned, delusions when humans mistake noise for signal, and hallucinations when cognitive distortions take hold. Every major correction in science—every paradigm shift—is not just a struggle against ignorance but against the false realities that the scientific process itself has produced. Fraud and delusion, then, are not mere side effects of science; they are intrinsic to its unfolding. The challenge is not simply to eliminate them but to learn how to manage and recognize them.

Show code cell source Hide code cell source

import matplotlib.pyplot as plt
import networkx as nx

# Function to create the CoffeeTree network with colored nodes and edges
def create_colored_coffee_network():
    G = nx.DiGraph()
    
    # Define nodes with colors
    nodes = {
        "Red Eye": "brown",
        "Drip": "lightblue",
        "Blonde Roast": "lightblue",
        "Pike Place": "lightblue",
        "Dark Roast": "lightblue",
        "Espresso": "lightgreen",
        "Espresso (Solo/Doppio)": "lightgreen",
        "Americano": "lightgreen",
        "Custom Made": "lightgreen",
        "Latte": "lightpink",
        "Cappuccino": "lightpink",
        "Macchiato": "lightpink"
    }
    
    # Add nodes to graph
    for node, color in nodes.items():
        G.add_node(node, color=color)
    
    # Define edges with colors
    edges = [
        ("Red Eye", "Drip", "lightblue"),  # Drip branch
        ("Red Eye", "Espresso", "lightgreen"),  # Espresso branch
        ("Drip", "Blonde Roast", "lightblue"),
        ("Drip", "Pike Place", "lightblue"),
        ("Drip", "Dark Roast", "lightblue"),
        ("Espresso", "Espresso (Solo/Doppio)", "lightgreen"),
        ("Espresso", "Americano", "lightgreen"),
        ("Espresso", "Custom Made", "lightgreen"),
        ("Custom Made", "Latte", "lightpink"),
        ("Custom Made", "Cappuccino", "lightpink"),
        ("Custom Made", "Macchiato", "lightpink"),
    ]
    
    # Add edges to graph
    for source, target, color in edges:
        G.add_edge(source, target, color=color)
    
    return G, nodes

# Function to extract edge colors for visualization
def get_edge_colors(G):
    return [G[u][v]['color'] for u, v in G.edges]

# Function to extract node colors for visualization
def get_node_colors(G, nodes):
    return [nodes[node] for node in G.nodes]

# Create the network with colored nodes and edges
coffee_network, node_colors = create_colored_coffee_network()

# Plot the network with specified colors
plt.figure(figsize=(12, 8))

# Set a fixed seed for layout consistency
pos = nx.spring_layout(coffee_network, seed=3)  

# Get edge and node colors for plotting
edge_colors = get_edge_colors(coffee_network)
node_colors_list = get_node_colors(coffee_network, node_colors)

# Draw the network
nx.draw(
    coffee_network,
    pos,
    with_labels=True,
    node_color=node_colors_list,
    node_size=3000,
    font_size=10,
    font_weight="bold",
    edge_color=edge_colors,
    arrowsize=20,
    width=2
)

# Add a title to the diagram
plt.title("Starbucks Coffee")
plt.show()

Interestingly, what science seeks to minimize—fraud, delusion, and hallucination—becomes a strategic virtue in adversarial contexts like poker, warfare, politics, and business. In poker, deception is not an aberration but a core strategy. A strong player does not just rely on good hands but manipulates opponents through false signals, bluffing to create a structured distortion of reality. This is fraud repurposed as an information weapon—a calculated asymmetry designed to extract advantage.

The same principle applies to other domains. Military deception has been a fundamental strategy for centuries, from Sun Tzu’s “all warfare is based on deception” to the elaborate feints of World War II. In business, startups inflate projections to secure funding, knowing that markets reward perception as much as reality. In politics, campaign promises that will never be fulfilled function as strategic bluffs, shaping public expectations and opponent responses. In these domains, fraud is not a failure of the system—it is the system. The best players master deception while maintaining credibility, a delicate balance between trust and manipulation.

Beyond outright fraud, self-delusion can be an asset in games and strategy. Poker players often construct narratives about their own skill, reinforcing a selective illusion of control that enhances performance. Confidence, even if misplaced, can tilt probability in one’s favor. Many of history’s great leaders were borderline delusional, but their belief in their own inevitability altered reality. Napoleon, Steve Jobs, and Elon Musk all weaponized their self-belief, bending the world to fit their vision. Even in financial markets, a well-timed false narrative—such as “crypto is the future” during a speculative bubble—can become a self-fulfilling prophecy, at least for a time.

Even outright hallucinations can have strategic value. False pattern recognition in games can lead to unexpected strategies that confound opponents. In innovation, imagining a future that does not yet exist can drive real breakthroughs—the Wright brothers had to “hallucinate” controlled flight before aerodynamics could be properly understood. In military history, entire campaigns have been won because one side mistakenly perceived weakness where there was none, or saw strength in a phantom army that never existed. These hallucinations, though incorrect, shaped outcomes in ways that rational strategies could not.

This brings us to an adversarial equilibrium: when fraud, delusion, and hallucination are not just tolerated but necessary. In adversarial environments, truth is only one tool among many. The greatest players do not simply seek reality; they manipulate it. They navigate between knowing when to tell the truth (credibility), when to deceive (fraud), when to believe their own myths (delusion), and when to hallucinate the future (vision). This is why pure rationality is often insufficient in games, war, and business. The best strategists are not just logical but strategically irrational, capable of simulating an alternate world and then forcing it into existence.

This oscillation between truth-seeking and deception brings us back to science. Science aims for truth, but it operates within a world of incentives, power, and human psychology. The fraud, delusions, and hallucinations that plague science are not always bugs—they are features of a larger competitive ecosystem of knowledge. The challenge is not simply eliminating them but understanding when they accelerate discovery versus when they corrupt it.

In the end, science and deception are two sides of the same coin. Science attempts to reduce fraud, delusion, and hallucination; poker and games optimize them. The real world exists somewhere between these two poles, and mastery lies in knowing when to embrace each.

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-Entropy', 'Planet-Tempered', 'Life-Needs', 'Ecosystem-Costs', 'Generative-Means', 'Cartel-Ends', ], # Polytheism, Olympus, Kingdom
        'Perception': ['Perception-Ledger'], # God, Judgement Day, Key
        'Agency': ['Open-Nomiddleman', 'Closed-Trusted'], # Evil & Good
        'Generative': ['Ratio-Weaponized', 'Competition-Tokenized', 'Odds-Monopolized'], # Dynamics, Compromises
        'Physical': ['Volatile-Revolutionary', 'Unveiled-Resentment',  'Freedom-Dance in Chains', 'Exuberant-Jubilee', 'Stable-Conservative'] # Values
    }

# Assign colors to nodes
def assign_colors():
    color_map = {
        'yellow': ['Perception-Ledger'],
        'paleturquoise': ['Cartel-Ends', 'Closed-Trusted', 'Odds-Monopolized', 'Stable-Conservative'],
        'lightgreen': ['Generative-Means', 'Competition-Tokenized', 'Exuberant-Jubilee', 'Freedom-Dance in Chains', 'Unveiled-Resentment'],
        'lightsalmon': [
            'Life-Needs', 'Ecosystem-Costs', 'Open-Nomiddleman', # Ecosystem = Red Queen = Prometheus = Sacrifice
            'Ratio-Weaponized', 'Volatile-Revolutionary'
        ],
    }
    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'))  # Default color fallback

    # 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("Inversion as Transformation", fontsize=15)
    plt.show()

# Run the visualization
visualize_nn()

Fig. 24 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.