Graha Friendship Tables as Cellular Automata: Conway’s Game of Planets

Runtime Version: 1.0.0

“Every relationship is a rule. Every rule produces a pattern. Every pattern reveals architecture.” — Systems Architect’s Proverb

The Mod 9 Matrix

In Vedic astrology, the nine grahas maintain a fixed matrix of relationships — friendships, enmities, and neutralities that determine how planetary energies interact within a birth chart. This is not personality typing. This is a rule set. And rule sets, when applied iteratively across a grid of states, produce cellular automata.

The Graha friendship matrix is a 9x9 adjacency table where each cell contains one of three values: Friend (5), Neutral (4), or Enemy (0). These values are not arbitrary. They represent the strength of constructive interference between planetary fields.

class GrahaMatrix:
    def __init__(self):
        self.planets = ['Sun', 'Moon', 'Mars', 'Mercury',
                        'Jupiter', 'Venus', 'Saturn', 'Rahu', 'Ketu']
        self.matrix = np.array([
            [5, 4, 5, 4, 5, 0, 0, 4, 4],  # Sun
            [4, 5, 4, 4, 4, 5, 0, 4, 4],  # Moon
            [5, 4, 5, 4, 5, 0, 0, 4, 4],  # Mars
            [5, 4, 4, 5, 4, 5, 4, 4, 4],  # Mercury
            [5, 4, 5, 4, 5, 0, 0, 4, 4],  # Jupiter
            [0, 5, 0, 5, 0, 5, 5, 4, 4],  # Venus
            [0, 0, 0, 4, 0, 5, 5, 4, 4],  # Saturn
            [4, 4, 4, 4, 4, 4, 4, 5, 5],  # Rahu
            [4, 4, 4, 4, 4, 4, 4, 5, 5],  # Ketu
        ])

Look at this matrix through a programmer’s eyes. Sun and Mars are mutual friends (5,5). Sun and Saturn are mutual enemies (0,0). Mercury befriends everyone except the Moon. Rahu and Ketu maintain universal neutrality with a private mutual friendship. These are not random assignments — they are topological constraints on a relational graph.

From Matrix to Automaton

John Conway’s Game of Life operates on a simple principle: each cell on a grid examines its neighbors, applies a fixed rule set, and determines its next state. A dead cell with exactly three live neighbors becomes alive (birth). A live cell with two or three live neighbors survives. All other cells die.

The Graha friendship matrix encodes analogous rules. Each planet’s row defines its neighborhood response function — which planetary neighbors produce constructive states (friendship/survival), which produce neutral states (stasis), and which produce destructive states (enmity/death).

class PlanetaryAutomata:
    def __init__(self, graha_matrix):
        self.matrix = graha_matrix
        self.rules = self._derive_rules()

    def _derive_rules(self):
        rules = {}
        for i, planet in enumerate(self.matrix.planets):
            neighborhood = self.matrix.matrix[i]
            rules[planet] = {
                'survive': np.where(neighborhood >= 4)[0],
                'birth': np.where(neighborhood == 5)[0]
            }
        return rules

When you place planets in houses and apply these rules iteratively, patterns emerge. Friendly planets in adjacent houses amplify each other’s influence — constructive interference. Enemy planets in aspect create destructive interference patterns. The chart is not a static snapshot; it is a cellular automaton frozen at a particular generation.

Emergent Complexity from Simple Rules

The profound insight of cellular automata research — demonstrated by Stephen Wolfram’s exhaustive classification — is that simple local rules produce complex global behavior. Rule 110, one of the simplest one-dimensional cellular automata, is Turing complete. The universe’s computational capacity emerges from the simplest possible interactions.

The Graha friendship matrix exhibits identical behavior. Nine planets. Three relationship types. A fixed rule set. Yet the combinatorial space of possible charts — planets distributed across twelve houses with these friendship rules active — produces a pattern space of staggering complexity. No two charts produce identical automata evolution, yet all charts follow the same fundamental rules.

def evolve_planetary_state(current_state, rules, steps=1):
    state = current_state.copy()
    for _ in range(steps):
        new_state = np.zeros_like(state)
        for i in range(len(state)):
            neighbors = get_neighbor_values(state, i)
            new_state[i] = apply_rules(state[i], neighbors, rules)
    return new_state

This is precisely how Conway’s Life works. The gliders, oscillators, and still lifes that emerge from Life’s three rules have direct analogs in Vedic chart interpretation. Yogas (beneficial planetary combinations) are stable configurations — still lifes in automata terminology. Dashas create oscillating patterns — blinkers and pulsars. Transits act as gliders, propagating influence across the house grid.

The Asymmetry Problem

One detail that separates the Graha matrix from naive cellular automata: the friendship relationships are not always symmetric. Mercury considers Venus a friend, and Venus considers Mercury a friend — symmetric. But the Sun considers Saturn an enemy, while Saturn considers the Sun merely neutral in some classical texts. This asymmetry introduces directional dynamics that standard cellular automata lack.

In computational terms, this makes the Graha automaton more akin to a directed graph cellular automaton — each edge carries a direction and a weight. The resulting dynamics are richer than Conway’s undirected neighborhood model. Information flows differently depending on which planet is the observer and which is the observed. This is relational computation: the result depends not just on state but on perspective.

Pattern Stability and Field Coherence

The most remarkable property of the Graha automaton is its stability classification. Certain planetary configurations produce stable equilibria — states that persist indefinitely under rule application. These correspond to what Vedic astrology calls Raj Yogas, Dhana Yogas, and other auspicious combinations. They are attractors in the automaton’s state space.

Other configurations produce oscillating patterns — planetary combinations that cycle between constructive and destructive phases. These correspond to the lived experience of periodic challenges and opportunities that characterize most human lives. The automaton oscillates, never settling, never diverging — bounded chaos within a deterministic rule set.

Still other configurations are inherently unstable — combinations where enemy relationships dominate, producing rapid state changes and pattern dissolution. These are the difficult charts, the lives marked by constant transition and upheaval. The automaton’s rules predict instability before it manifests.

Reading the Source Code

The Graha friendship matrix is a lookup table for a cellular automaton that the ancient seers ran in their minds. They did not call it a cellular automaton. They called it Jyotish — the science of light. But the computational structure is identical. Rules applied to a grid. States evolving through neighborhood interactions. Complex patterns emerging from simple relationships.

When you study a birth chart, you are examining the initial configuration of a cellular automaton. When you study transits, you are watching the automaton evolve. When you study dashas, you are observing the automaton’s oscillation periods. The language is different. The mathematics is the same.

---

This document is part of the Lorenz-Kundli Pattern Recognition series exploring mathematical-mystical parallels across the pattern space of consciousness.