Update app.py

app.py

@@ -1,10 +1,10 @@
 import gradio as gr
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-from matplotlib.animation import FuncAnimation
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
 import numpy as np
-from io import BytesIO
-import base64
+from collections import Counter
+import math
 
 # Historical researchers of perfect numbers - Enhanced HTML version
 MATHEMATICIANS = """
@@ -70,13 +70,18 @@ def prime_factorization(n):
     return factors
 
 def divisors(n):
-    """Find all divisors of n"""
-    divs = []
-    for i in range(1, int(n**0.5) + 1):
+    """Find all divisors of n efficiently"""
+    if n == 1:
+        return [1]
+    
+    divs = set()
+    sqrt_n = int(math.isqrt(n))
+    
+    for i in range(1, sqrt_n + 1):
         if n % i == 0:
-            divs.append(i)
-            if i != n // i:
-                divs.append(n // i)
+            divs.add(i)
+            divs.add(n // i)
+    
     return sorted(divs)
 
 def classify_number(n, proper_sum):
@@ -101,119 +106,140 @@ def check_perfect(n):
     return proper_sum == n, divs, proper_sum, classification, emoji
 
 def create_enhanced_visualization(n):
-    """Create comprehensive visualization with multiple plots"""
-    n = int(n)
+    """Create comprehensive visualization with Plotly for any positive integer"""
+    try:
+        n = int(n)
+    except (ValueError, TypeError):
+        return "Please enter a valid positive integer.", None
+    
     if n <= 0:
         return "Please enter a positive integer.", None
     
-    # Warning for very large numbers
-    if n > 10000000:
-        return f"⚠️ Warning: {n} is too large for efficient visualization. Please try a number below 10,000,000.", None
-    
     is_perfect, divs, proper_sum, classification, emoji = check_perfect(n)
     proper_divs = [d for d in divs if d != n]
     
-    # Create figure with multiple subplots
-    fig = plt.figure(figsize=(16, 10))
-    fig.patch.set_facecolor('#f0f0f0')
+    # Create subplots with Plotly
+    fig = make_subplots(
+        rows=2, cols=3,
+        subplot_titles=(
+            f'Proper Divisors of {n}',
+            'Divisor Magnitudes',
+            f'{classification} Number Analysis {emoji}',
+            'Divisor Pairs',
+            f'Prime Factorization of {n}',
+            'Perfect Number Definition'
+        ),
+        specs=[
+            [{"type": "pie"}, {"type": "bar"}, {"type": "bar"}],
+            [{"type": "table"}, {"type": "table"}, {"type": "table"}]
+        ],
+        vertical_spacing=0.1,
+        horizontal_spacing=0.05
+    )
     
     # Define color scheme
     if classification == "Perfect":
-        color_scheme = plt.cm.Greens
         main_color = '#2ecc71'
+        colors = px.colors.sequential.Greens[2:8]
     elif classification == "Abundant":
-        color_scheme = plt.cm.Blues
         main_color = '#3498db'
+        colors = px.colors.sequential.Blues[2:8]
     else:
-        color_scheme = plt.cm.Reds
         main_color = '#e74c3c'
+        colors = px.colors.sequential.Reds[2:8]
     
     # 1. PIE CHART - Divisor Distribution
-    ax1 = plt.subplot(2, 3, 1)
     if proper_divs:
-        colors = color_scheme(np.linspace(0.3, 0.9, len(proper_divs)))
-        wedges, texts, autotexts = ax1.pie(
-            proper_divs, 
-            labels=[str(d) for d in proper_divs],
-            autopct='%1.1f%%',
-            startangle=90,
-            colors=colors,
-            explode=[0.05] * len(proper_divs),
-            shadow=True
+        # Limit to top 20 divisors for readability
+        display_divs = proper_divs[:20] if len(proper_divs) > 20 else proper_divs
+        fig.add_trace(
+            go.Pie(
+                labels=[str(d) for d in display_divs],
+                values=display_divs,
+                textinfo='label+percent',
+                insidetextorientation='radial',
+                marker=dict(colors=colors * (len(display_divs) // len(colors) + 1)),
+                textfont=dict(size=12),
+                hovertemplate="Divisor: %{label}<br>Value: %{value}<extra></extra>"
+            ),
+            row=1, col=1
         )
-        for autotext in autotexts:
-            autotext.set_color('white')
-            autotext.set_fontweight('bold')
-    ax1.set_title(f'Proper Divisors of {n}', fontsize=12, fontweight='bold', pad=20)
     
     # 2. BAR CHART - Divisor Values
-    ax2 = plt.subplot(2, 3, 2)
     if proper_divs:
-        bars = ax2.bar(range(len(proper_divs)), proper_divs, color=colors, edgecolor='black', linewidth=1.5)
-        ax2.set_xticks(range(len(proper_divs)))
-        ax2.set_xticklabels([str(d) for d in proper_divs], rotation=45, ha='right')
-        ax2.set_ylabel('Value', fontweight='bold')
-        ax2.set_title('Divisor Magnitudes', fontsize=12, fontweight='bold', pad=20)
-        ax2.grid(axis='y', alpha=0.3, linestyle='--')
-        
-        # Add value labels on bars
-        for bar in bars:
-            height = bar.get_height()
-            ax2.text(bar.get_x() + bar.get_width()/2., height,
-                    f'{int(height)}',
-                    ha='center', va='bottom', fontweight='bold')
+        # Limit to top 20 divisors for readability
+        display_divs = proper_divs[:20] if len(proper_divs) > 20 else proper_divs
+        fig.add_trace(
+            go.Bar(
+                x=[str(d) for d in display_divs],
+                y=display_divs,
+                marker_color=main_color,
+                text=display_divs,
+                textposition='outside',
+                hovertemplate="Divisor: %{x}<br>Value: %{y}<extra></extra>"
+            ),
+            row=1, col=2
+        )
+        fig.update_xaxes(tickangle=45, row=1, col=2)
     
     # 3. COMPARISON BAR - Sum vs Number
-    ax3 = plt.subplot(2, 3, 3)
     comparison = [proper_sum, n]
-    labels = [f'Sum of Divisors\n({proper_sum})', f'Number\n({n})']
-    bars = ax3.bar(labels, comparison, color=[main_color, '#95a5a6'], edgecolor='black', linewidth=2)
-    ax3.set_ylabel('Value', fontweight='bold')
-    ax3.set_title(f'{classification} Number Analysis {emoji}', fontsize=12, fontweight='bold', pad=20)
-    ax3.grid(axis='y', alpha=0.3, linestyle='--')
+    labels = [f'Sum of Divisors<br>({proper_sum})', f'Number<br>({n})']
+    fig.add_trace(
+        go.Bar(
+            x=labels,
+            y=comparison,
+            marker_color=[main_color, '#95a5a6'],
+            text=comparison,
+            textposition='outside',
+            hovertemplate="%{x}<br>Value: %{y}<extra></extra>"
+        ),
+        row=1, col=3
+    )
     
     # Add difference annotation
     diff = abs(proper_sum - n)
-    diff_pct = (diff / n) * 100
-    ax3.text(0.5, max(comparison) * 0.5, 
-            f'Difference: {diff}\n({diff_pct:.1f}%)',
-            ha='center', va='center',
-            bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8),
-            fontsize=10, fontweight='bold')
+    diff_pct = (diff / n) * 100 if n != 0 else 0
+    fig.add_annotation(
+        x=0.5, y=max(comparison) * 0.5,
+        text=f"Difference: {diff}<br>({diff_pct:.1f}%)",
+        showarrow=False,
+        bgcolor="wheat",
+        bordercolor="black",
+        font=dict(size=12, color="black"),
+        row=1, col=3
+    )
     
     # 4. DIVISOR PAIRS VISUALIZATION
-    ax4 = plt.subplot(2, 3, 4)
-    ax4.axis('off')
-    
-    # Show divisor pairs
-    pairs_text = "🔗 **Divisor Pairs:**\n\n"
-    sqrt_n = int(n**0.5)
+    sqrt_n = int(math.isqrt(n))
     pairs = []
     for d in proper_divs:
         if d <= sqrt_n and d != n // d:
             pairs.append((d, n // d))
     
-    for i, (d1, d2) in enumerate(pairs):
-        pairs_text += f"{d1} × {d2} = {n}\n"
-    
-    if n in divs:
-        if int(n**0.5)**2 == n:
-            pairs_text += f"{int(n**0.5)} × {int(n**0.5)} = {n} ✓"
-    
-    ax4.text(0.1, 0.9, pairs_text, transform=ax4.transAxes,
-            fontsize=10, verticalalignment='top', family='monospace',
-            bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.7))
+    if pairs:
+        pair_labels = [f"{d1} × {d2}" for d1, d2 in pairs]
+        pair_values = [n] * len(pairs)
+        fig.add_trace(
+            go.Table(
+                header=dict(values=["Divisor Pairs", "Product"]),
+                cells=dict(values=[pair_labels, pair_values]),
+                columnwidth=[100, 50]
+            ),
+            row=2, col=1
+        )
+    else:
+        fig.add_trace(
+            go.Table(
+                header=dict(values=["Divisor Pairs"]),
+                cells=dict(values=[["No pairs found"]])
+            ),
+            row=2, col=1
+        )
     
     # 5. PRIME FACTORIZATION
-    ax5 = plt.subplot(2, 3, 5)
-    ax5.axis('off')
-    
     prime_factors = prime_factorization(n)
-    factor_text = f"🔢 **Prime Factorization of {n}:**\n\n"
-    
     if prime_factors:
-        # Count occurrences
-        from collections import Counter
         factor_counts = Counter(prime_factors)
         factor_parts = []
         for prime in sorted(factor_counts.keys()):
@@ -222,50 +248,61 @@ def create_enhanced_visualization(n):
                 factor_parts.append(f"{prime}")
             else:
                 factor_parts.append(f"{prime}^{count}")
-        factor_text += " × ".join(factor_parts)
+        factorization = " × ".join(factor_parts)
     else:
-        factor_text += "1 (unity)"
-    
-    factor_text += f"\n\n📊 **Number Properties:**\n"
-    factor_text += f"• Total divisors: {len(divs)}\n"
-    factor_text += f"• Proper divisors: {len(proper_divs)}\n"
-    factor_text += f"• Sum of all divisors: {sum(divs)}\n"
-    factor_text += f"• Classification: {classification} {emoji}"
-    
-    ax5.text(0.1, 0.9, factor_text, transform=ax5.transAxes,
-            fontsize=10, verticalalignment='top', family='monospace',
-            bbox=dict(boxstyle='round', facecolor='lightyellow', alpha=0.7))
+        factorization = "1 (unity)"
+    
+    properties = [
+        f"Total divisors: {len(divs)}",
+        f"Proper divisors: {len(proper_divs)}",
+        f"Sum of all divisors: {sum(divs)}",
+        f"Classification: {classification} {emoji}"
+    ]
+    
+    fig.add_trace(
+        go.Table(
+            header=dict(values=["Prime Factorization", "Number Properties"]),
+            cells=dict(values=[[factorization], ["<br>".join(properties)]])
+        ),
+        row=2, col=2
+    )
     
     # 6. MATHEMATICAL FORMULA
-    ax6 = plt.subplot(2, 3, 6)
-    ax6.axis('off')
-    
-    formula_text = "📐 **Perfect Number Definition:**\n\n"
-    formula_text += "A perfect number equals the sum\n"
-    formula_text += "of its proper divisors:\n\n"
-    
     if proper_divs:
-        sum_parts = " + ".join([str(d) for d in proper_divs])
-        if len(sum_parts) > 50:
-            # Truncate if too long
-            sum_parts = sum_parts[:47] + "..."
-        formula_text += f"{sum_parts}\n= {proper_sum}\n\n"
+        sum_parts = " + ".join([str(d) for d in proper_divs[:10]])  # Limit to first 10
+        if len(proper_divs) > 10:
+            sum_parts += " + ..."
+        formula = f"{sum_parts} = {proper_sum}"
+    else:
+        formula = "No proper divisors"
+    
+    result = f"{'✅' if is_perfect else '❌'} {proper_sum} {'=' if is_perfect else '≠'} {n}"
     
     if is_perfect:
-        formula_text += f"✅ {proper_sum} = {n}\n"
-        formula_text += f"Therefore, {n} is PERFECT! 🎉"
+        conclusion = "PERFECT NUMBER! 🎉"
+    elif classification == "Abundant":
+        conclusion = f"Abundant (Excess: {proper_sum - n})"
     else:
-        formula_text += f"❌ {proper_sum} ≠ {n}\n"
-        if classification == "Abundant":
-            formula_text += f"Sum exceeds number\n(Abundant)"
-        else:
-            formula_text += f"Sum is less than number\n(Deficient)"
-    
-    ax6.text(0.1, 0.9, formula_text, transform=ax6.transAxes,
-            fontsize=10, verticalalignment='top', family='monospace',
-            bbox=dict(boxstyle='round', facecolor='lightgreen' if is_perfect else 'lightcoral', alpha=0.7))
+        conclusion = f"Deficient (Deficiency: {n - proper_sum})"
+    
+    fig.add_trace(
+        go.Table(
+            header=dict(values=["Perfect Number Definition"]),
+            cells=dict(values=[[formula, result, conclusion]])
+        ),
+        row=2, col=3
+    )
     
-    plt.tight_layout(pad=3.0)
+    # Update layout
+    fig.update_layout(
+        height=800,
+        showlegend=False,
+        title_text=f"Comprehensive Analysis of {n}",
+        title_x=0.5,
+        title_font_size=24,
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)'
+    )
     
     # Generate detailed message with HTML formatting
     msg = f"""
@@ -280,14 +317,14 @@ def create_enhanced_visualization(n):
         
         <div style='background: white; padding: 20px; border-radius: 10px; margin-bottom: 20px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); border-left: 6px solid #2196F3;'>
             <h3 style='color: #1976D2; margin-top: 0;'>📊 Divisor Information</h3>
-            <p style='font-size: 16px; line-height: 1.8; color: #000;'><strong style='color: #000;'>All Divisors:</strong> <span style='color: #0D47A1; font-weight: bold;'>{divs}</span></p>
-            <p style='font-size: 16px; line-height: 1.8; color: #000;'><strong style='color: #000;'>Proper Divisors (excluding {n}):</strong> <span style='color: #0D47A1; font-weight: bold;'>{proper_divs}</span></p>
+            <p style='font-size: 16px; line-height: 1.8; color: #000;'><strong style='color: #000;'>All Divisors:</strong> <span style='color: #0D47A1; font-weight: bold;'>{divs[:20]}{"..." if len(divs) > 20 else ""}</span></p>
+            <p style='font-size: 16px; line-height: 1.8; color: #000;'><strong style='color: #000;'>Proper Divisors (excluding {n}):</strong> <span style='color: #0D47A1; font-weight: bold;'>{proper_divs[:20]}{"..." if len(proper_divs) > 20 else ""}</span></p>
         </div>
         
         <div style='background: white; padding: 20px; border-radius: 10px; margin-bottom: 20px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); border-left: 6px solid #FF9800;'>
             <h3 style='color: #F57C00; margin-top: 0;'>🧮 Sum Calculation</h3>
             <p style='font-size: 18px; line-height: 1.8; font-weight: bold;'>
-                {' + '.join([f"<span style='background: #FFE0B2; color: #BF360C; padding: 3px 8px; border-radius: 5px; margin: 2px; display: inline-block;'>{d}</span>" for d in proper_divs])} = <span style='background: #FF6F00; color: white; padding: 5px 12px; border-radius: 5px;'>{proper_sum}</span>
+                {' + '.join([f"<span style='background: #FFE0B2; color: #BF360C; padding: 3px 8px; border-radius: 5px; margin: 2px; display: inline-block;'>{d}</span>" for d in proper_divs[:10]])}{" + ..." if len(proper_divs) > 10 else ""} = <span style='background: #FF6F00; color: white; padding: 5px 12px; border-radius: 5px;'>{proper_sum}</span>
             </p>
         </div>
         
@@ -312,31 +349,32 @@ def create_enhanced_visualization(n):
 # Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft(), title="Perfect Number Explorer") as demo:
     gr.Markdown("""
-    # 🔢 Perfect Number Visualizer & Explorer
+    # 🔢 Perfect Number Visualizer & Explorer (Unlimited Range!)
     
     ### What are Perfect Numbers?
     A **perfect number** is a positive integer that equals the sum of its proper divisors (divisors excluding the number itself).
     
     **Example:** 6 is perfect because 1 + 2 + 3 = 6
     
-    ### Try these perfect numbers: 6, 28, 496, 8128
+    ### Try these perfect numbers: 6, 28, 496, 8128, 33550336
+    ### Or try very large numbers like 2^31-1 (2147483647) or even larger!
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
             number_input = gr.Number(
-                label="Enter a Number (1 - 1,000,000)", 
+                label="Enter ANY Positive Integer", 
                 value=6,
                 precision=0
             )
             analyze_btn = gr.Button("🔍 Analyze Number", variant="primary", size="lg")
             
             gr.Markdown("""
-            ### Quick Facts:
-            - Only 51 perfect numbers are known
-            - All known perfect numbers are even
-            - No odd perfect number has ever been found
-            - Perfect numbers are extremely rare!
+            ### Key Features:
+            - **Unlimited Range**: Analyze ANY positive integer (no upper limit!)
+            - **Optimized Algorithms**: Efficiently handles very large numbers
+            - **Interactive Visualizations**: Zoom, pan, and hover for details
+            - **Comprehensive Analysis**: Divisors, factorization, and classification
             """)
     
     with gr.Row():
@@ -345,7 +383,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Perfect Number Explorer") as demo:
         )
     
     with gr.Row():
-        plot_output = gr.Plot(label="📈 Visual Analysis")
+        plot_output = gr.Plot(label="📈 Interactive Visual Analysis")
     
     analyze_btn.click(
         fn=create_enhanced_visualization,