🔍 Twin Primes & Digit Root Attractors

🎯 What’s New?

We’re taking our twin prime exploration one step further by analyzing their digit root compression and tracking how often certain digit root pairs appear. These pairs act like attractors—revealing hidden numerical patterns.

🧠 Mathematical Concepts

• Twin Primes: Prime pairs that differ by 2
• Digit Sum: Sum of digits of a number
• Digit Root Compression: Repeated digit summing until a single-digit result
• Attractor Pair: Final digit roots of twin primes, sorted and counted

💻 Python Code

from collections import defaultdict

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_sum(n):
    return sum(int(d) for d in str(n))

def compress_to_single_digit(n):
    steps = []
    while n >= 10:
        steps.append(n)
        n = digit_sum(n)
    steps.append(n)
    return steps

def find_twin_primes_with_compression(start, end):
    twin_primes = []
    for i in range(start, end - 1):
        if is_prime(i) and is_prime(i + 2):
            twin_primes.append((i, i + 2))
    return twin_primes

# 🚀 User Input
try:
    start_range = int(input("Enter starting range: "))
    end_range = int(input("Enter ending range: "))

    if start_range >= end_range:
        print("❌ Starting range must be less than ending range.")
    else:
        twins = find_twin_primes_with_compression(start_range, end_range)
        attractor_counts = defaultdict(int)

        print(f"\nTwin primes between {start_range} and {end_range} with digit compression:")
        for a, b in twins:
            a_steps = compress_to_single_digit(digit_sum(a))
            b_steps = compress_to_single_digit(digit_sum(b))
            a_root = a_steps[-1]
            b_root = b_steps[-1]
            pair = tuple(sorted((a_root, b_root)))
            attractor_counts[pair] += 1

            print(f"({a}, {b}) → ({digit_sum(a)}, {digit_sum(b)}) → {a_root}, {b_root}")
            print(f"  Steps: {a_steps} vs {b_steps}")

        if not twins:
            print("No twin primes found in this range.")
        else:
            print("\n📊 Attractor Pair Frequencies:")
            for pair, count in sorted(attractor_counts.items(), key=lambda x: -x[1]):
                print(f"Digit Root Pair {pair}: {count} occurrences")

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

Copy and Try it here!

📊 Sample Output

Input: 10 to 50

Output:

(11, 13) → (2, 4) → 2, 4
  Steps: [2] vs [4]
(17, 19) → (8, 10) → 8, 1
  Steps: [8] vs [10, 1]
(29, 31) → (11, 4) → 2, 4
  Steps: [11, 2] vs [4]

📊 Attractor Pair Frequencies:
Digit Root Pair (2, 4): 2 occurrences
Digit Root Pair (1, 8): 1 occurrence

🔍 Why It’s Fascinating

Digit root attractors offer a new lens to study prime behavior. Some pairs appear more frequently, hinting at underlying structure. This blend of coding and number theory opens doors to deeper exploration.

🌟 Final Thoughts

Try different ranges and analyze the attractor frequencies. Are certain digit root pairs more dominant? Can you predict them? This is a great way to merge algorithmic thinking with mathematical intuition.