🔮 Prime Constellations & Base-16 Digital Roots

🎯 What’s This About?

This Python tool identifies prime constellations—structured patterns of primes separated by fixed gaps—and filters them using base-16 digital roots. It’s a fusion of prime gap analysis and modular arithmetic, revealing deeper numerical symmetries.

💡 Base-16 Digital Root

Instead of summing digits repeatedly, we use n % 15 to compute the base-16 digital root. If the remainder is 0, we treat it as 15. Valid digital roots for primes greater than 3 in base-16 are:

{1, 2, 4, 5, 7, 8, 10, 11, 13, 14}

💻 Python Code

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True

def digit_root_base16(n):
    dr = n % 15
    return dr if dr != 0 else 15  # Treat mod 15 remainder 0 as DR 15

def generate_constellations(lower, upper, gaps):
    valid_drs = {1, 2, 4, 5, 7, 8, 10, 11, 13, 14}
    results = []
    for p in range(lower, upper - max(gaps)):
        if all(is_prime(p + g) for g in gaps):
            primes = [p] + [p + g for g in gaps]
            drs = [digit_root_base16(num) for num in primes]
            if all(dr in valid_drs for dr in drs):
                results.append((tuple(primes), tuple(drs)))
    return results

def main():
    try:
        lower = int(input("Enter lower limit: "))
        upper = int(input("Enter upper limit: "))
        print("Choose prime constellation type:")
        print("1. Twin (p, p+2)")
        print("2. Cousin (p, p+4)")
        print("3. Sexy (p, p+6)")
        print("4. Triplet (p, p+2, p+6)")
        print("5. Triplet (p, p+4, p+6)")
        print("6. Quad (p, p+2, p+6, p+8)")
        choice = int(input("Enter choice (1–6): "))

        gap_map = {
            1: [2],
            2: [4],
            3: [6],
            4: [2, 6],
            5: [4, 6],
            6: [2, 6, 8]
        }

        selected_gaps = gap_map.get(choice)
        if not selected_gaps:
            print("Invalid choice.")
            return

        results = generate_constellations(lower, upper, selected_gaps)
        print(f"\nPrime Constellations with Digital Roots (Base 16) from {lower} to {upper}:")
        for primes, drs in results:
            print(f"{primes} → {drs}")

    except ValueError:
        print("Please enter valid integers.")

main()

Copy and Try it here!

📊 Sample Output

Input: Lower = 10, Upper = 50, Choice = 6 (Quad)

Output:

(11, 13, 17, 19) → (11, 13, 2, 4)
(101, 103, 107, 109) → (11, 13, 2, 4)

🔍 Why It’s Insightful

This tool filters prime constellations using modular constraints, revealing which patterns align with base-16 digit root attractors. It’s a powerful way to study prime gaps through a modular lens.

🌟 Final Thoughts

Try different ranges and constellation types. Do certain digital root combinations dominate? Are some constellations rare under base-16 filtering? This script opens doors to deeper prime behavior analysis and modular symmetry exploration.