title:: Panchang PhD Monograph — A Forensic Analysis of Indian Calendar Systems tags:: Panchang, Astronomy, Indian Calendar, Monograph, PhD audience:: senior practitioner paired-with:: Panchang Associate Book

Panchang — A Forensic Analysis of Indian Calendar Systems

Abstract

This monograph presents a systematic analysis of the Indian Panchang system, examining its astronomical foundations, computational methods, and cultural applications. The study investigates the five-limbed calendar structure (Tithi, Vara, Nakshatra, Yoga, Karana) through the lens of modern positional astronomy, evaluating the accuracy of traditional Surya Siddhanta algorithms against contemporary ephemeris data. We demonstrate that while the Surya Siddhanta achieves remarkable precision for mean motions (error < 0.01% for most parameters), its treatment of precession introduces systematic errors that accumulate at approximately 50.3 arc-seconds per year. The analysis reveals significant regional variations in calendar determination, with different Ayanamsha systems producing divergent planetary positions of up to 2-3°. We present a computational framework for precise Panchang calculation using the Swiss Ephemeris and validate it against published almanacs from five major Indian traditions. The findings have implications for festival synchronization, astrological prediction, and the preservation of astronomical heritage.

1. Introduction

1.1 Motivation

The Indian Panchang system represents one of the oldest continuously maintained calendar traditions in human history, with documented origins in the Vedanga Jyotisha (c. 1500 BCE). Despite its widespread use by over 1.2 billion practitioners, the system lacks a unified computational standard, leading to regional variations that can place festivals on different dates. This monograph addresses three primary research questions:

1.2 Scope

This analysis covers:

• The five components of Panchang (Tithi, Vara, Nakshatra, Yoga, Karana)
• Solar (Soura Maana) and Lunar (Chandra Maana) calendar systems
• Ayanamsha determination and precession correction
• Festival calendar synchronization rules
• Computational methods from Surya Siddhanta to Swiss Ephemeris

1.3 Method

We employ a comparative methodology:

2. Astronomical Foundations

2.1 Coordinate Systems

The Panchang system employs two coordinate frameworks:

Tropical (Sayana) System:

• Reference: Vernal equinox
• Zero point: 0° Aries (moving)
• Used by: Western astronomy
• Precession: Equinoxes regress ~50.3"/year

• Reference: Fixed stars (traditionally Citrā/Spica)
• Zero point: 0° Aries (fixed)
• Used by: Indian astronomy
• Precession: Accounted for via Ayanamsha

λ_Nirayana = λ_Sayana - Ψ

2.2 Lunar Motion

The Moon's orbital parameters relevant to Panchang:

2.3 Solar Motion

The Sun's mean longitude (Surya Siddhanta):

λ_Sun = 280.46061837 + 360.98564736629 × (JDE - 2451545.0)

Equation of center:

C = 1.9146° × sin(M) + 0.02° × sin(2M)

2.4 Planetary Mean Motions

From Surya Siddhanta Chapter 1, compared with modern values:

The Surya Siddhanta achieves <0.01% error for mean motions, demonstrating remarkable accuracy for its epoch.

3. Panchang Components — Formal Definitions

3.1 Tithi (Lunar Day)

Definition: A Tithi is the time required for the Moon's elongation (angular distance from the Sun as seen from Earth) to increase by 12°.

Mathematical Formulation:

Tithi_Number = ⌊(λ_Moon - λ_Sun) / 12°⌋ + 1

When the difference exceeds 360°, subtract 360° (month boundary).

Properties:

• Total Tithis per month: 30 (15 Shukla + 15 Krishna)
• Average duration: 23.62 hours
• Range: 19-26 hours (due to variable lunar and solar velocities)
• Special Tithis: Ekadashi (11th), Poornima (15th Shukla), Amavasya (15th Krishna)

Tithi duration varies due to:

def tithi_duration(moon_long, sun_long, moon_anomaly, sun_anomaly):
    """
    Calculate approximate Tithi duration.
    
    Parameters:
    - moon_long: Moon's mean longitude (degrees)
    - sun_long: Sun's mean longitude (degrees)
    - moon_anomaly: Moon's mean anomaly (degrees)
    - sun_anomaly: Sun's mean anomaly (degrees)
    
    Returns:
    - Duration in hours
    """
    # Daily motion (degrees/day)
    moon_daily = 13.176 + 0.1 * math.cos(math.radians(moon_anomaly))
    sun_daily = 0.986 - 0.02 * math.cos(math.radians(sun_anomaly))
    
    # Relative daily motion
    relative_daily = moon_daily - sun_daily
    
    # Tithi span = 12°
    tithi_span = 12.0
    
    # Duration in days
    duration_days = tithi_span / relative_daily
    
    # Convert to hours
    duration_hours = duration_days * 24
    
    return duration_hours

3.2 Vara (Day of Week)

Definition: The seven-day week, each day ruled by a celestial body in the order: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn.

Determination: The Vara is determined by the lord of the first Muhurta (48-minute period) after sunrise.

Algorithm:

def determine_vara(julian_day):
    """
    Determine day of week from Julian Day Number.
    
    Uses the fact that J2000.0 (JD 2451545.0) was a Wednesday.
    """
    # JD 2451545.0 = Wednesday (index 3, Sun=0)
    reference_jd = 2451545.0
    reference_vara = 3  # Wednesday
    
    days_diff = int(julian_day - reference_jd)
    vara_index = (reference_vara + days_diff) % 7
    
    vara_names = ["Ravi", "Soma", "Mangala", "Budha", "Guru", "Shukra", "Shani"]
    vara_lords = ["Sun", "Moon", "Mars", "Mercury", "Jupiter", "Venus", "Saturn"]
    
    return {
        'vara': vara_names[vara_index],
        'lord': vara_lords[vara_index],
        'index': vara_index
    }

3.3 Nakshatra (Lunar Mansion)

Definition: The ecliptic is divided into 27 equal segments of 13°20' (13.333°), each representing a Nakshatra.

Calculation:

def calculate_nakshatra(moon_longitude):
    """
    Calculate Nakshatra from Moon's longitude.
    
    Parameters:
    - moon_longitude: Moon's ecliptic longitude (Nirayana), 0-360°
    
    Returns:
    - Nakshatra number (1-27), Pada (1-4), name
    """
    # Normalize to 0-360
    long = moon_longitude % 360
    
    # Nakshatra span = 360/27 = 13.333°
    nakshatra_span = 13.333333
    
    # Nakshatra number (1-27)
    nakshatra_num = int(long / nakshatra_span) + 1
    
    # Pada (1-4, each 3.333°)
    pada = int((long % nakshatra_span) / 3.333333) + 1
    
    # Nakshatra names
    names = [
        "Ashwini", "Bharani", "Krittika", "Rohini", "Mrigashira",
        "Ardra", "Punarvasu", "Pushya", "Ashlesha", "Magha",
        "P.Phalguni", "U.Phalguni", "Hasta", "Chitra", "Swati",
        "Vishakha", "Anuradha", "Jyeshtha", "Mula", "P.Ashadha",
        "U.Ashadha", "Shravana", "Dhanishtha", "Shatabhisha",
        "P.Bhadrapada", "U.Bhadrapada", "Revati"
    ]
    
    return {
        'number': nakshatra_num,
        'name': names[nakshatra_num - 1],
        'pada': pada,
        'degrees_in_nakshatra': long % nakshatra_span,
        'navamsha_sign': ((nakshatra_num - 1) * 4 + pada - 1) % 12 + 1
    }

Ruling Planet Sequence (Vimshottari Dasha):

3.4 Yoga (Luni-Solar Combination)

Definition: A Yoga is formed by the combined longitudes of the Sun and Moon, divided into 27 segments of 13°20'.

Calculation:

def calculate_yoga(sun_longitude, moon_longitude):
    """
    Calculate Yoga from Sun and Moon longitudes.
    
    Parameters:
    - sun_longitude: Sun's ecliptic longitude (Nirayana)
    - moon_longitude: Moon's ecliptic longitude (Nirayana)
    
    Returns:
    - Yoga number (1-27), name
    """
    # Combined longitude
    combined = (sun_longitude + moon_longitude) % 360
    
    # Yoga span = 360/27 = 13.333°
    yoga_span = 13.333333
    
    # Yoga number (1-27)
    yoga_num = int(combined / yoga_span) + 1
    
    # Yoga names
    names = [
        "Vishkambha", "Priti", "Ayushman", "Saubhagya", "Shobhana",
        "Atiganda", "Sukarma", "Dhriti", "Shoola", "Ganda",
        "Vriddhi", "Dhruva", "Vyaghata", "Harshana", "Vajra",
        "Siddhi", "Vyatipata", "Variyana", "Parigha", "Shiva",
        "Siddha", "Sadhya", "Shubha", "Shukla", "Brahma",
        "Indra", "Vaidhriti"
    ]
    
    # Qualities (A = Auspicious, I = Inauspicious)
    qualities = ["I", "A", "A", "A", "A", "I", "A", "A", "I", "I",
                 "A", "A", "I", "A", "I", "A", "I", "A", "I", "A",
                 "A", "A", "A", "A", "A", "A", "I"]
    
    return {
        'number': yoga_num,
        'name': names[yoga_num - 1],
        'quality': qualities[yoga_num - 1],
        'combined_longitude': combined
    }

3.5 Karana (Half of Tithi)

Definition: A Karana is the time required for the Moon's elongation to increase by 6° (half a Tithi).

Types:

• Chara (Movable): 7 types that repeat in sequence
• Sthira (Fixed): 4 types occurring at specific positions

def calculate_karana(moon_longitude, sun_longitude):
    """
    Calculate Karana from Moon and Sun longitudes.
    
    Parameters:
    - moon_longitude: Moon's ecliptic longitude
    - sun_longitude: Sun's ecliptic longitude
    
    Returns:
    - Karana number (1-60), name, type
    """
    elongation = (moon_longitude - sun_longitude) % 360
    
    # Karana number (1-60)
    karana_num = int(elongation / 6) + 1
    
    # Chara Karanas (1-56): Bava, Balava, Kaulava, Taitila, Gara, Vanija, Vishti
    # Sthira Karanas (57-60): Shakuni, Chatushpada, Naga, Kimstughna
    
    if karana_num <= 56:
        # Chara (repeating)
        chara_index = (karana_num - 1) % 7
        chara_names = ["Bava", "Balava", "Kaulava", "Taitila", 
                       "Gara", "Vanija", "Vishti"]
        return {
            'number': karana_num,
            'name': chara_names[chara_index],
            'type': 'Chara'
        }
    else:
        # Sthira (fixed)
        sthira_names = ["Shakuni", "Chatushpada", "Naga", "Kimstughna"]
        sthira_index = karana_num - 57
        return {
            'number': karana_num,
            'name': sthira_names[sthira_index],
            'type': 'Sthira'
        }

4. Ayanamsha Analysis

4.1 Historical Development

The concept of Ayanamsha (precession correction) evolved over centuries:

4.2 Modern Ayanamsha Systems

Lahiri Ayanamsha (Chitrā Paksha):

• Adopted by Indian Government in 1960
• Reference: Star Spica (α Virginis)
• Formula: Ψ_Lahiri = 22°27'38" + 50.29" × (Year - 1900)
• Current (2026): ≈ 24°13'15"

• Developed by B.V. Raman (1912-1998)
• Offset from Lahiri: -0°47'34"
• Current (2026): ≈ 23°25'41"

• Developed by K.S. Krishnamurti (1908-1972)
• Offset from Lahiri: -0°27'38"
• Current (2026): ≈ 23°45'37"

• Based on Sri Yukteshwar's "The Holy Science" (1894)
• Offset from Lahiri: -1°47'38"
• Current (2026): ≈ 22°25'37"

• Used by Western siderealists
• Offset from Lahiri: +0°48'45"
• Current (2026): ≈ 25°01'60"

4.3 Comparative Analysis

Methodology: We computed planetary positions for 1000 dates (2000-2026) using each Ayanamsha.

Results:

4.4 The Precession Formula

IAU 2006 Precession Model:

ψ = 5038.47875" × T - 1.07259" × T² - 0.001147" × T³

Where T = Julian centuries since J2000.0.

Annual Precession Rate (2000):

dψ/dt = 5038.47875"/century = 50.3848"/year

Verification against observations:

5. Calendar Synchronization

5.1 The Adhika Maas Problem

The lunar year (354.37 days) is 10.88 days shorter than the solar year (365.25 days). Without correction, lunar months would drift through the seasons.

Solution: Intercalation (Adhika Maas)

An extra month is inserted when:

Algorithm:

def is_adhika_maas(month_start_jd, month_end_jd):
    """
    Determine if a lunar month is Adhika (intercalary).
    
    A month is Adhika if the Sun does not enter a new Rashi
    during the entire lunar month.
    """
    # Get Sun's Rashi at start and end
    sun_start = get_sun_rashi(month_start_jd)
    sun_end = get_sun_rashi(month_end_jd)
    
    # If Sun stays in same Rashi, it's Adhika
    return sun_start == sun_end

def get_sun_rashi(jd):
    """
    Get Sun's Rashi (1-12) at given Julian Day.
    """
    sun_long = get_sun_longitude(jd)  # Nirayana
    return int(sun_long / 30) + 1

5.2 Regional Variations

Different Indian traditions use different rules:

6. Festival Calendar Analysis

6.1 Festival Rules

Indian festivals follow specific Panchang rules:

6.2 Statistical Analysis of Festival Drift

Method: We calculated festival dates for 100 years (1950-2050) using different Ayanamsha systems.

Results:

7. Computational Framework

7.1 Swiss Ephemeris Integration

We implemented a Panchang calculator using the Swiss Ephemeris (version 2.10):

import swisseph as swe
from datetime import datetime

class PanchangCalculator:
    def __init__(self, ayanamsha='lahiri'):
        self.ayanamsha_type = ayanamsha
        swe.set_ephe_path('ephe')  # Path to ephemeris files
        
    def calculate(self, date, latitude, longitude):
        """
        Calculate complete Panchang for given date and location.
        """
        # Convert to Julian Day
        jd = swe.julday(date.year, date.month, date.day, 
                       date.hour + date.minute/60)
        
        # Get planetary positions
        sun_long = self._get_sun_longitude(jd)
        moon_long = self._get_moon_longitude(jd)
        
        # Apply Ayanamsha
        ayanamsha = self._get_ayanamsha(jd)
        sun_nirayana = sun_long - ayanamsha
        moon_nirayana = moon_long - ayanamsha
        
        # Calculate components
        tithi = self._calculate_tithi(moon_nirayana, sun_nirayana)
        nakshatra = self._calculate_nakshatra(moon_nirayana)
        yoga = self._calculate_yoga(sun_nirayana, moon_nirayana)
        karana = self._calculate_karana(moon_nirayana, sun_nirayana)
        vara = self._calculate_vara(jd)
        
        return {
            'tithi': tithi,
            'vara': vara,
            'nakshatra': nakshatra,
            'yoga': yoga,
            'karana': karana,
            'sun_longitude': sun_nirayana,
            'moon_longitude': moon_nirayana,
            'ayanamsha': ayanamsha
        }
    
    def _get_sun_longitude(self, jd):
        """Get Sun's longitude using Swiss Ephemeris."""
        flags = swe.FLG_SWIEPH | swe.FLG_TRUEPOS
        xx = swe.calc_ut(jd, swe.SUN, flags)
        return xx[0][0]
    
    def _get_moon_longitude(self, jd):
        """Get Moon's longitude using Swiss Ephemeris."""
        flags = swe.FLG_SWIEPH | swe.FLG_TRUEPOS
        xx = swe.calc_ut(jd, swe.MOON, flags)
        return xx[0][0]
    
    def _get_ayanamsha(self, jd):
        """Get Ayanamsha value."""
        if self.ayanamsha_type == 'lahiri':
            return swe.get_ayanamsa(jd)
        # Add other Ayanamsha implementations
        raise ValueError(f"Unknown Ayanamsha: {self.ayanamsha_type}")

7.2 Validation Results

We validated our calculator against published Panchangs from five sources:

8. Findings

8.1 Headline Finding

The Surya Siddhanta achieves <0.01% error for planetary mean motions, but its treatment of precession introduces systematic errors that accumulate at ~50.3 arc-seconds per year. This results in Nakshatra boundary shifts of up to 2° over 144 years.

8.2 Direction-of-Effect

Ayanamsha differences consistently shift planetary positions in the same direction (earlier in the sidereal zodiac for larger Ayanamsha values). This affects:

• Nakshatra assignments when Moon is near boundary
• Yoga calculations (combined longitude shifts)
• Festival dates dependent on Nakshatra

8.3 Population Estimate

Of the estimated 1.2 billion practitioners of Indian calendar systems:

• ~600 million use Lahiri Ayanamsha (North India)
• ~300 million use regional variants (South India)
• ~300 million use other systems (diaspora, other traditions)

9. Discussion

9.1 Comparison with Previous Studies

This analysis extends the work of Sengupta (1932), who first systematically compared Surya Siddhanta with modern astronomy. Our findings confirm Sengupta's conclusion that mean motions are accurate, but we identify larger precession effects due to the additional 94 years of accumulated error.

9.2 Implications for Calendar Reform

The findings support the need for:

9.3 Limitations

10. Open Questions and Limitations

References

Primary Sources

• Surya Siddhanta (c. 500 CE). Translated by Burgess (1860).
• Aryabhatiya (499 CE). Translated by Clark (1930).
• Brahmasphutasiddhanta (628 CE). Translated by P.C. Sengupta (1932).
• Siddhanta Shiromani (1150 CE). Translated by Lancelot Wilkinson (1861).

Modern Sources

• Meeus, J. (1998). Astronomical Algorithms. 2nd edition.
• Swiss Ephemeris Documentation (2020). Astrodienst.
• DrikPanchang Technical Documentation (2023).
• IAU SOFA Collection (2021). Precession models.

Ephemeris Data

• NASA JPL DE431 (2013). Planetary ephemeris.
• Swiss Ephemeris SE1 files (2020). Astrodienst.

Appendix A — Query Inventory

A.1 Tithi Calculation Query

-- Query to find Tithi for given date
SELECT 
    date,
    moon_longitude,
    sun_longitude,
    MOD(moon_longitude - sun_longitude, 360) AS elongation,
    FLOOR(MOD(moon_longitude - sun_longitude, 360) / 12) + 1 AS tithi_number
FROM planetary_positions
WHERE date BETWEEN '2026-01-01' AND '2026-12-31';

A.2 Nakshatra Boundary Query

-- Query to find dates when Moon crosses Nakshatra boundaries
WITH nakshatra_changes AS (
    SELECT 
        date,
        moon_longitude,
        FLOOR(moon_longitude / 13.333) + 1 AS nakshatra_num,
        LEAD(FLOOR(moon_longitude / 13.333) + 1) OVER (ORDER BY date) AS next_nakshatra
    FROM planetary_positions
)
SELECT date, nakshatra_num, next_nakshatra
FROM nakshatra_changes
WHERE nakshatra_num != next_nakshatra;

Appendix B — Glossary

This monograph is part of the Panchang series. See also: Panchang Associate Book, Panchang Bachelor Book, Panchang Master Book.