Base

Ritual & Exersion

Religion as Ritual: The Iterative Heart of Belief

Religion is fundamentally about rituals. These repetitive acts, grounded in tradition and symbolism, form the essence of communal and individual religious life. Rituals provide structure, anchor meaning, and foster connection—to others, to nature, to oneself. The idea of deities or a singular “Deity,” by contrast, is a relatively late-stage development. It’s akin to the symbol of Rosebud in Citizen Kane: a narrative device that ties the story together, but not the story itself. Much like the rug in The Big Lebowski, it “really ties the room together,” but it is the bowling ritual—the steady, repetitive practice—that drives the protagonist’s identity. Bowling cannot sustain a plot on its own for two hours, so the rug (and the ensuing chaos) must step in.

This distinction between ritual and deity mirrors the developmental trajectory of religious systems. Early practices were likely rooted in rituals—offerings, dances, chants—as expressions of awe or attempts to harmonize with natural cycles. The divine, as a concept, emerged later, almost as an explanatory shorthand for the ineffable forces these rituals engaged. Rituals iterated across generations, evolving but remaining fundamentally repetitive. The deity or deities were introduced to “explain” the rituals and make them coherent within a broader cosmology. Deities are the mustard tree; the rituals, the seeds.

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 {
        'Pre-Input': ['Life','Earth', 'Cosmos', 'Sound', 'Tactful', 'Firm', ],
        'Yellowstone': ['Deity'],
        'Input': ['Individual', 'Communal'],
        'Hidden': [
            'Fears',
            'Rituals',
            'Bonds',
        ],
        'Output': ['Art', 'Low-Skill', '10k-hr-Rule', 'High-Skill', 'Religion',    ]
    }

# Define weights for the connections
def define_weights():
    return {
        'Pre-Input-Yellowstone': np.array([
            [0.6],
            [0.5],
            [0.4],
            [0.3],
            [0.7],
            [0.8],
            [0.6]
        ]),
        'Yellowstone-Input': np.array([
            [0.7, 0.8]
        ]),
        'Input-Hidden': np.array([[0.8, 0.4, 0.1], [0.9, 0.7, 0.2]]),
        'Hidden-Output': np.array([
            [0.2, 0.8, 0.1, 0.05, 0.2],
            [0.1, 0.9, 0.05, 0.05, 0.1],
            [0.05, 0.6, 0.2, 0.1, 0.05]
        ])
    }

# Assign colors to nodes
def assign_colors(node, layer):
    if node == 'Deity':
        return 'yellow'
    if layer == 'Pre-Input' and node in ['Sound', 'Tactful', 'Firm']:
        return 'paleturquoise'
    elif layer == 'Input' and node == 'Communal':
        return 'paleturquoise'
    elif layer == 'Hidden':
        if node == 'Bonds':
            return 'paleturquoise'
        elif node == 'Rituals':
            return 'lightgreen'
        elif node == 'Fears':
            return 'lightsalmon'
    elif layer == 'Output':
        if node == 'Religion':
            return 'paleturquoise'
        elif node in ['High-Skill', '10k-hr-Rule', 'Low-Skill']:
            return 'lightgreen'
        elif node == 'Art':
            return 'lightsalmon'
    return 'lightsalmon'  # Default color

# Calculate positions for nodes
def calculate_positions(layer, center_x, offset):
    layer_size = len(layer)
    start_y = -(layer_size - 1) / 2  # Center the layer vertically
    return [(center_x + offset, start_y + i) for i in range(layer_size)]

# Create and visualize the neural network graph
def visualize_nn():
    layers = define_layers()
    weights = define_weights()
    G = nx.DiGraph()
    pos = {}
    node_colors = []
    center_x = 0  # Align nodes horizontally

    # Add nodes and assign positions
    for i, (layer_name, nodes) in enumerate(layers.items()):
        y_positions = calculate_positions(nodes, center_x, offset=-len(layers) + i + 1)
        for node, position in zip(nodes, y_positions):
            G.add_node(node, layer=layer_name)
            pos[node] = position
            node_colors.append(assign_colors(node, layer_name))

    # Add edges and weights
    for layer_pair, weight_matrix in zip(
        [('Pre-Input', 'Yellowstone'), ('Yellowstone', 'Input'), ('Input', 'Hidden'), ('Hidden', 'Output')],
        [weights['Pre-Input-Yellowstone'], weights['Yellowstone-Input'], weights['Input-Hidden'], weights['Hidden-Output']]
    ):
        source_layer, target_layer = layer_pair
        for i, source in enumerate(layers[source_layer]):
            for j, target in enumerate(layers[target_layer]):
                weight = weight_matrix[i, j]
                G.add_edge(source, target, weight=weight)

    # Customize edge thickness for specific relationships
    edge_widths = []
    for u, v in G.edges():
        if u in layers['Hidden'] and v == 'Kapital':
            edge_widths.append(6)  # Highlight key edges
        else:
            edge_widths.append(1)

    # Draw the graph
    plt.figure(figsize=(12, 16))
    nx.draw(
        G, pos, with_labels=True, node_color=node_colors, edge_color='gray',
        node_size=3000, font_size=10, width=edge_widths
    )
    edge_labels = nx.get_edge_attributes(G, 'weight')
    nx.draw_networkx_edge_labels(G, pos, edge_labels={k: f'{v:.2f}' for k, v in edge_labels.items()})
    plt.title("Let There Be Light: Genesis 1:3")
    
    # Save the figure to a file
    # plt.savefig("figures/logo.png", format="png")

    plt.show()

# Run the visualization
visualize_nn()

Fig. 16 Paleturquoise, lightgreen, lightsalmon: Paradiso, Purgatorio, Inferno. The color-coding corresponds to Dante’s Magna Opera ^{3 2 1}. And the lightgray represents the raw, unprocessed, yet-to-be transformed inputs. These triadic themes spawn an unlimited number of variants. For instance, the adversary-identity-tokenization-joy nodes can be thought of as tragical-comical-historical-pastoral. They align with the tragedy of commons, mistaken identity as the most accessible resource for comedy, and the history of mankind being a story of encoding everything into symbol, language, token, and commodity to facilitate dialogue

Ritual and Repetition: The Iterative Algorithm of Religion

Rituals are iterative by nature. They operate like a feedback loop: practice begets meaning, and meaning reinforces practice. Consider the cyclical nature of religious calendars—Shabbat every week, Ramadan every year, or Easter’s rolling arrival. These cycles are not incidental but integral, encoding lessons about time, mortality, and renewal. They are the bowling alley of human life, keeping us within lanes.

The iteration of rituals fosters stability, both psychological and social. Repetition soothes. It creates predictability in an unpredictable world. It also generates collective identity: shared rituals are the foundation of communities. Imagine the simplest ritual: a shared meal. Across cultures and religions, eating together becomes sacred through repetition, from Christian communion to the Jewish Passover seder.

Deity & Cognition

Deities as Emergent Symbols: Rosebud, The Rug, and “God”

If rituals are iterative processes, deities are the emergent phenomena—the outputs of a cultural neural network. Like Rosebud in Citizen Kane, the deity enters the story not to drive it but to explain it. In The Big Lebowski, The Dude’s rug becomes a token of narrative cohesion, much like a deity becomes a token of spiritual coherence. Yet, it is The Dude’s bowling—his sacred ritual—that defines his existence. Without it, the film loses its grounding. Similarly, religion without rituals is hollow. “God” without the repetitive acts of prayer, fasting, or gathering remains an abstract, lifeless idea.

In a neural network, rituals are the iterative steps that adjust weights, slowly refining the model. The deity is the final output—the compressed symbol that emerges from countless iterations. This emergent quality doesn’t diminish the deity’s significance but situates it as a culmination of collective human experience rather than its origin.

Bowling and Religion: Iteration in Action

Consider bowling as a metaphor for religious practice. Each frame is a ritual, and the act of rolling the ball is a repeated engagement with a structured environment. The pins stand in for obstacles, the alley for life’s constraints. Yet, no one watches a two-hour film about bowling alone. The Big Lebowski distracts us with chaos, crime, and comedy—all centering around The Dude’s rug. But The Dude’s true anchor is the bowling ritual. The rug—like a deity—is a narrative necessity, but it is the bowling alley that gives his life shape.

Seeds and Mustard Trees

In religious terms, rituals are the seeds, small and unassuming, yet vital. Deities are the mustard trees, grand and conspicuous, but reliant on those seeds for growth. To focus solely on the deity is to misunderstand the foundation upon which it stands. Just as a neural network depends on countless iterations to yield its final outputs, religions depend on rituals—repeated, evolving, but constant—to sustain their meaning and relevance.

Religion’s iterative core is its strength. Like Rosebud, the deity emerges as a symbolic tie to a sprawling narrative. But it is the iterative practice—the ritual—that carries the weight, shaping and reshaping the human spirit across generations.

Worship & Vision

The idea that religions begin as rituals and later incorporate deities, with sensory representations arriving last, has a compelling logic grounded in anthropology, cognitive science, and historical observation. Here’s an argument in favor of this progression:

---

I. Ritual as the Primordial Foundation

Religions are, at their core, frameworks for shared behavior, providing structure and cohesion to early human groups. Exertional activities like dancing, feasting, chanting, and sacrifices are primal and universal. These behaviors align with:

1. Social Cohesion: Rituals create trust and mutual investment. Durkheim argued that collective rituals reinforce social bonds and community solidarity. Long before abstract thinking, humans needed mechanisms to coordinate group behavior.

2. Muscle Memory: Physical acts like bowing, drumming, or fasting are deeply embodied practices that don’t rely on abstract cognition. They focus on “doing,” not “thinking.”

3. Neuroendocrine Feedback: Exertional rituals often stimulate the release of neurochemicals like dopamine, oxytocin, and endorphins, reinforcing their significance in social bonding and personal commitment.

Examples of ritual without explicit deities include early shamanistic practices, where gestures, rhythmic sounds, and communal acts took precedence over theological constructs.

---

II. Cognition and the Emergence of Deities

Deities enter the picture when cognition matures to a point where abstract reasoning and storytelling can frame the world. Early humans began asking why rituals mattered and posited causal agents—spirits or gods—to explain the effects of their actions.

1. Anthropomorphic Projection: Cognitive science suggests humans naturally ascribe agency to unexplained phenomena. This is evident in the “hyperactive agency detection device” (HADD) theory, where humans assume intentionality behind natural events like storms or earthquakes.

2. Myth Creation: Deities likely arose to narrativize the rituals, turning them into acts with meaning. For example:

   • In early Vedic traditions, rituals (like fire offerings) predate the formal codification of gods like Indra or Agni.

   • Similarly, ancestor veneration in African and Asian traditions is grounded in practice long before structured pantheons emerge.

At this stage, the concept of a deity is a cognitive anchor—a way to explain and justify rituals.

---

III. Sensory Representations of Deities

Sensory depictions—visual, auditory, or tactile—are a relatively late development, likely because they require technological and artistic advances. Even in religions with deities, their sensory representation is often secondary or absent in early stages.

1. Abrahamic Religions: Early Judaism strictly prohibited visual depictions of God, reflecting a focus on covenant and law (behavior) over sensory input. Christianity eventually adopted iconic imagery, but this became widespread only after the Roman Empire institutionalized the faith.

   • Da Vinci’s “Last Supper” and Michelangelo’s Sistine Chapel are products of the late medieval and Renaissance periods, far removed from Christianity’s origins.

   • Islam, to this day, avoids sensory depictions of Allah, focusing instead on the Qur’an as an auditory and textual manifestation.

2. Hinduism and Polytheistic Traditions: While some polytheistic religions have rich iconographies, these often develop after rituals and myths are established. For example:

   • The Indus Valley Civilization (3300–1300 BCE) left no concrete images of Hindu deities, though later periods produced iconic depictions like Vishnu and Shiva.

3. Technology and Craftsmanship: Sensory representations are resource-intensive. The creation of statues, frescoes, or illuminated manuscripts often correlates with surplus wealth, technological capability, and artistic innovation, which occur in advanced societies.

---

Supporting Evidence from Anthropology and History

1. Göbekli Tepe (c. 9600–9500 BCE): This archaeological site shows large-scale ritual activity predating evidence of settled agriculture or hierarchical societies. There are no definitive signs of deities, though the site includes symbolic carvings.

2. The Axial Age (800–200 BCE): Major religions like Buddhism, Zoroastrianism, and early Judaism emerged with strong cognitive and ethical frameworks but often downplayed sensory depictions of the divine.

3. Medieval Christian Art: The sensory explosion of religious art in Europe didn’t occur until the Renaissance (14th–17th centuries), after centuries of abstract theological development.

---

Conclusion

The progression from ritual (behavior) to cognition (deities) to sensory input (depictions) reflects the layered evolution of human culture:

1. Behavior and exertion form the foundation because they are rooted in embodied, neuroendocrine responses.

2. Cognition introduces meaning and explanation, allowing rituals to persist across generations as acts of devotion to deities.

3. Sensory input arrives last, offering a material representation of the abstract divine, tied to technological and social advancement.

This framework aligns with historical evidence and highlights the adaptive, iterative nature of religion. While not all religions follow this exact pattern, the theory provides a cohesive lens for understanding their origins and evolution.