Twin Primes & Digit Compression: A Python Exploration

🔢 Twin Primes Meet Digit Compression

🎯 What’s the Idea?

We’re combining two beautiful concepts from number theory:

• Twin Primes: Pairs of primes that differ by 2
• Digit Root Compression: Repeatedly summing digits until a single-digit result is obtained

🧠 Mathematical Insight

Digit root compression is a form of digital fingerprinting. It helps us explore patterns and symmetry in numbers. When applied to twin primes, it reveals curious similarities and differences in their compressed forms.

💻 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_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)
        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))
            print(f"({a}, {b}) → ({digit_sum(a)}, {digit_sum(b)}) → {a_steps[-1]}, {b_steps[-1]}")
            print(f"  Steps: {a_steps} vs {b_steps}")
        if not twins:
            print("No twin primes found in this range.")
except ValueError:
    print("❌ Please enter valid integers.")

Copy and Try it here!

📊 Sample Output

Input: 10 to 30

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]

🔍 Why It’s Cool

This approach blends algorithmic thinking with mathematical curiosity. You’re not just checking primes—you’re compressing their essence into a single digit and comparing their digital behavior.

🌟 Final Thoughts

Try different ranges and observe how digit roots behave across twin primes. Are there patterns? Are some digit roots more common? This is a great way to explore number theory interactively and prepare for exams like CSIR NET with a creative twist.