Veiled Resentment#
Francis Bacon’s critique of Aristotelian certainty was a foundational break from the rigid, deductive reasoning that had dominated medieval scholarship. Aristotle’s logical framework, particularly his syllogistic method, assumes that if the premises are true, the conclusion follows with certainty. Bacon, however, found this deeply flawed because it relied on axioms that were often taken as given rather than rigorously tested. He saw Aristotelian certainty as a self-reinforcing system that generated internally consistent but externally unverified truths. His alternative—inductive reasoning—demanded a bottom-up approach where knowledge emerges through systematic observation, experimentation, and incremental refinement.
Fig. 23 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”.#
This neural network’s structure directly challenges the Aristotelian model in ways that reflect Bacon’s critique. In Aristotle’s system, knowledge is hierarchical and categorical; an entity is either this or that based on established definitions. The network, by contrast, operates probabilistically, emphasizing transition states and dynamic weighting rather than fixed truths. The presence of Voir as a mediating layer (“Cool-Aid”) suggests an initial perceptual phase where ideas are neither fully accepted nor dismissed but are subject to reweighting—a rejection of Aristotelian certainty in favor of Baconian inquiry.
Where Aristotle would begin with established truths and deduce consequences, Bacon insisted that truth must be constructed iteratively. The Choisis layer (Faith vs. Reason) reflects this struggle. Faith, as traditionally associated with Aristotelian metaphysics, leans adversarially, reinforcing Bacon’s critique that dogmatic certainty resists new information. Reason, while not completely rejecting adversarial engagement, trends toward a more iterative, transactional process, suggesting an openness to adaptation. The presence of probabilistic transitions rather than binary outcomes in this network mirrors Bacon’s argument that knowledge must be built through trial and error, rather than assumed a priori.
A key aspect of Bacon’s attack on Aristotelian certainty was his insistence that observation must precede theory, a principle embodied in Deviens. Here, knowledge does not start with preordained conclusions but moves through adversarial, transactional, and hopeful equilibria—testing hypotheses through confrontation, negotiation, and tentative optimism. This progression starkly contrasts with Aristotle’s teleological framework, where things move toward a predefined end. Bacon rejected the idea that nature was driven by fixed purposes, advocating instead for an empirical approach where understanding emerges only after rigorous examination.
The M’èléve layer serves as the final refutation of Aristotelian certainty. Aristotle’s knowledge system is largely about classification, fitting observations into established categories. But this network does not merely classify—it distributes. The weighted edges leading to “Distribution” (99/1 from Adversarial) suggest that truth, once hard-won through skepticism and struggle, eventually becomes self-evident, aligning with Bacon’s idea that properly tested knowledge transcends mere assertion and becomes functional, applicable, and widely accepted. This is the essence of Bacon’s Novum Organum: knowledge must be tested, purified of biases, and then disseminated for collective advancement.
Ultimately, this neural network functions as a computational embodiment of Bacon’s philosophy. It does not assume truth—it constructs it. It does not demand certainty—it iterates toward it. In rejecting Aristotelian rigidity for a probabilistic, reweighting system, this network is not just aligned with Bacon’s critique; it is a direct realization of his vision.
Show code cell source
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
# Define the neural network layers
def define_layers():
return {
'Suis': ['Aprés Moi', 'Déluge', 'Syntax', 'Punctuation', "Rhythm", 'Nature'], # Static
'Voir': ['Cool-Aid'],
'Choisis': ['Faith', 'Reason'],
'Deviens': ['Adversarial', 'Transactional', 'Hopeful'],
"M'èléve": ['Victory', 'Payoff', 'Loyalty', 'Charity', 'Distribution']
}
# Assign colors to nodes
def assign_colors():
color_map = {
'yellow': ['Cool-Aid'],
'paleturquoise': ['Nature', 'Reason', 'Hopeful', 'Distribution'],
'lightgreen': ["Rhythm", 'Transactional', 'Payoff', 'Charity', 'Loyalty'],
'lightsalmon': ['Syntax', 'Punctuation', 'Faith', 'Adversarial', 'Victory'],
}
return {node: color for color, nodes in color_map.items() for node in nodes}
# Define edge weights (hardcoded for editing)
def define_edges():
return {
('Aprés Moi', 'Cool-Aid'): '1/99',
('Déluge', 'Cool-Aid'): '5/95',
('Syntax', 'Cool-Aid'): '20/80',
('Punctuation', 'Cool-Aid'): '51/49',
("Rhythm", 'Cool-Aid'): '80/20',
('Nature', 'Cool-Aid'): '95/5',
('Cool-Aid', 'Faith'): '20/80',
('Cool-Aid', 'Reason'): '80/20',
('Faith', 'Adversarial'): '49/51',
('Faith', 'Transactional'): '80/20',
('Faith', 'Hopeful'): '95/5',
('Reason', 'Adversarial'): '5/95',
('Reason', 'Transactional'): '20/80',
('Reason', 'Hopeful'): '51/49',
('Adversarial', 'Victory'): '80/20',
('Adversarial', 'Payoff'): '85/15',
('Adversarial', 'Loyalty'): '90/10',
('Adversarial', 'Charity'): '95/5',
('Adversarial', 'Distribution'): '99/1',
('Transactional', 'Victory'): '1/9',
('Transactional', 'Payoff'): '1/8',
('Transactional', 'Loyalty'): '1/7',
('Transactional', 'Charity'): '1/6',
('Transactional', 'Distribution'): '1/5',
('Hopeful', 'Victory'): '1/99',
('Hopeful', 'Payoff'): '5/95',
('Hopeful', 'Loyalty'): '10/90',
('Hopeful', 'Charity'): '15/85',
('Hopeful', 'Distribution'): '20/80'
}
# 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()
edges = define_edges()
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 with weights
for (source, target), weight in edges.items():
if source in G.nodes and target in G.nodes:
G.add_edge(source, target, weight=weight)
# Draw the graph
plt.figure(figsize=(12, 8))
edges_labels = {(u, v): d["weight"] for u, v, d in G.edges(data=True)}
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"
)
nx.draw_networkx_edge_labels(G, pos, edge_labels=edges_labels, font_size=8)
plt.title("Heritage vs. Adaptation", fontsize=15)
plt.show()
# Run the visualization
visualize_nn()
Fig. 24 Aristotle’s method is top-down and deductive, beginning with axiomatic truths and using logical syllogisms to derive conclusions, prioritizing internal consistency over empirical verification. His framework assumes that if the premises are sound, the conclusion necessarily follows, reinforcing a stable, hierarchical knowledge system rooted in classification and definition. Bacon, in stark contrast, rejects this static certainty in favor of a bottom-up, inductive approach that builds knowledge through systematic observation, experimentation, and external testing. Rather than accepting inherited truths, Bacon’s method accumulates empirical data, refines hypotheses through iteration, and subjects knowledge to real-world scrutiny, making it adaptive, self-correcting, and ultimately more aligned with the unpredictability of nature.#