The Dynamic Prime Cantor Set: A Fractal Woven from the Primes

mindmap
  root((Dynamic Prime Cantor Set))
    Construction Method
      Dynamic Process
        k_th step with p_k prime
        Subdivide into p_k + 1 pieces
        Remove prime indexed pieces
      Classic vs Dynamic
        Static Cantor removal
        Prime driven removal rules
    Mathematical Properties
      Topological Features
        Compact Set
        Perfect Set
        Totally Disconnected
      Measure Theory
        Zero Lebesgue Measure
        Hausdorff Dimension to 1
    Prime Number Connections
      Prime Number Theorem
        Distribution Analysis
        Counting Function pi(x)
      Prime Gaps Influence
        Local Fractal Structure
        Global Regularity
    Geometric Embeddings
      Hyperbolic Geometry
        Poincare Disk
        Fractal Boundary Subset
        Geodesic Tree Structure
      Visualization Methods
        Iterative Construction
        Prime Distribution Plots

Video Presentation

Introduction: Fractals, Primes, and a Dynamic Dance

The world of mathematics is rich with structures exhibiting intricate complexity arising from simple rules. Fractals, characterized by self-similarity and non-integer dimensions, offer stunning visual and conceptual depth, with the Cantor middle-thirds set serving as a foundational example. Separately, the prime numbers – those integers divisible only by one and themselves – form the multiplicative bedrock of arithmetic, yet their distribution along the number line remains one of mathematics’ most profound mysteries. Their sequence, \(2, 3, 5, 7, 11, \dots\), appears erratic locally but exhibits remarkable regularity on a global scale, as described by the Prime Number Theorem.

What happens when these two seemingly disparate domains – the recursive geometry of fractals and the fundamental arithmetic of primes – are deliberately intertwined? The classic Cantor set arises from a static, unchanging rule: remove the middle third. This paper introduces a novel construction, the Dynamic Prime Cantor (DPC) set, where the static rule is replaced by a dynamic one dictated by the sequence of prime numbers itself.

import matplotlib.pyplot as plt
import numpy as np

def sieve_of_eratosthenes(limit):
    """Generate prime numbers up to limit using Sieve of Eratosthenes"""
    is_prime = [True] * (limit + 1)
    is_prime[0] = is_prime[1] = False
    
    for i in range(2, int(limit**0.5) + 1):
        if is_prime[i]:
            for j in range(i*i, limit + 1, i):
                is_prime[j] = False
    
    return [i for i in range(2, limit + 1) if is_prime[i]]

# Generate first 100 primes
primes = sieve_of_eratosthenes(541)[:100]  # First 100 primes

plt.figure(figsize=(12, 4))
plt.scatter(primes, [1] * len(primes), alpha=0.6, s=30)
plt.yticks([])
plt.xlabel("Value")
plt.title("First 100 Prime Numbers Distribution")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Distribution of the first 100 prime numbers on the number line

At each stage of the DPC construction, corresponding to a new prime \(p_k\), the surviving intervals are refined based on \(p_k\), and subintervals are removed based on the count of primes up to \(p_k\). This process weaves the very fabric of the prime sequence into the geometric structure of the resulting fractal. The set “breathes” in response to the primes: the density and refinement change step-by-step, influenced by the specific prime used and, implicitly, by the gaps between consecutive primes.

---

Prime Number Distribution Analysis

The distribution of prime numbers is fundamental to understanding the Dynamic Prime Cantor Set construction. Let’s visualize the prime counting function \(\pi(x)\) and its relationship to the logarithmic integral.

import math

def prime_counting_values(max_val):
    """Calculate π(x) for values up to max_val"""
    primes = sieve_of_eratosthenes(max_val)
    pi_values = []
    counts = 0
    for i in range(max_val + 1):
        while counts < len(primes) and primes[counts] <= i:
            counts += 1
        pi_values.append(counts)
    return pi_values

# Calculate π(x) up to 100
x_vals = range(2, 101)
pi_x = prime_counting_values(100)[2:]
x_ln_x = [x / math.log(x) if x > 1 else 0 for x in x_vals]

plt.figure(figsize=(12, 6))
plt.plot(x_vals, pi_x, 'b-', label='π(x)', linewidth=2)
plt.plot(x_vals, x_ln_x, 'r--', label='x/ln(x)', linewidth=2)
plt.xlabel('x')
plt.ylabel('Count')
plt.title('Prime Counting Function π(x) and its Asymptotic Approximation x/ln(x)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Prime counting function π(x) and its approximation x/ln(x)

The Prime Number Theorem states that \(\pi(x) \sim x/\ln x\), meaning the ratio approaches 1 as \(x\) approaches infinity. This theorem is crucial for understanding the behavior of our DPC set construction.

---

Construction of the Dynamic Prime Cantor Set

The construction follows a precise iterative procedure, starting with the unit interval and progressively removing portions based on the prime sequence.

Formal Definition

1. Initialization: Begin with the closed unit interval, \(S_0 = [0,1]\).
2. List the Primes: Let \(\{p_1, p_2, p_3, \dots\} = \{2, 3, 5, 7, 11, \dots\}\) be the sequence of prime numbers in increasing order.
3. Iterative Step (k ≥ 1): Assume the set \(S_{k-1}\) has been constructed. \(S_{k-1}\) is a finite disjoint union of closed intervals. To form \(S_k\):
   • For each closed interval \(I\) composing \(S_{k-1}\):
     • Divide \(I\) into \(p_k + 1\) closed subintervals of equal length.
     • Label these subintervals sequentially from left to right as \(1, 2, \dots, p_k + 1\).
     • Remove all subintervals whose label \(j\) is a prime number less than or equal to \(p_k\).
     • Keep the remaining \((p_k + 1) - \pi(p_k)\) subintervals.
   • Define \(S_k\) as the union of all kept subintervals arising from all intervals \(I\) in \(S_{k-1}\).

Iterative Visualization

Let’s visualize the first few steps of the construction:

import matplotlib.patches as patches

def construct_dpc_step(prev_intervals, k, prime_k):
    """Perform one step of DPC construction"""
    next_intervals = []
    pi_pk = len(sieve_of_eratosthenes(prime_k))  # Count of primes ≤ p_k
    
    for start, end in prev_intervals:
        interval_length = (end - start) / (prime_k + 1)
        
        # Keep intervals with non-prime labels (label is from 1 to p_k+1)
        primes_up_to_pk = set(sieve_of_eratosthenes(prime_k))
        
        for i in range(prime_k + 1):
            label = i + 1  # Labels from 1 to p_k+1
            new_start = start + i * interval_length
            new_end = start + (i + 1) * interval_length
            
            if label not in primes_up_to_pk:
                next_intervals.append((new_start, new_end))
    
    return next_intervals

def visualize_dpc_steps(steps=3):
    """Visualize the first few steps of DPC construction"""
    fig, axes = plt.subplots(steps, 1, figsize=(12, steps*2))
    if steps == 1:
        axes = [axes]

    # Get first few primes
    primes = sieve_of_eratosthenes(20)[:steps]
    
    # Initial interval
    current_intervals = [(0, 1)]
    
    for step in range(steps):
        ax = axes[step]
        
        # Draw current intervals
        for start, end in current_intervals:
            width = end - start
            rect = patches.Rectangle((start, 0.2), width, 0.6, linewidth=1, 
                                   edgecolor='black', facecolor='skyblue', alpha=0.7)
            ax.add_patch(rect)
        
        ax.set_xlim(0, 1)
        ax.set_ylim(0, 1)
        ax.set_title(f"Step {step+1}: Using prime p_{step+1} = {primes[step]}")
        ax.set_xlabel("Interval [0,1]")
        ax.set_yticks([])
        
        if step < steps - 1:
            # Perform next step
            current_intervals = construct_dpc_step(current_intervals, step, primes[step])
    
    plt.tight_layout()
    plt.show()

# Visualize first 3 steps
visualize_dpc_steps(3)

First 3 steps of the Dynamic Prime Cantor Set construction

Let’s also visualize the measure (total length) remaining at each step:

def calculate_dpc_measure(steps=10):
    """Calculate the total measure remaining after each step"""
    primes = sieve_of_eratosthenes(50)[:steps]
    measures = [1.0]  # Start with full measure
    
    for i in range(steps):
        pi_pk = len(sieve_of_eratosthenes(primes[i]))
        proportion_kept = (primes[i] + 1 - pi_pk) / (primes[i] + 1)
        measures.append(measures[-1] * proportion_kept)
    
    return measures[1:]  # Skip initial 1.0

# Calculate measure for first 15 steps
steps = 15
measures = calculate_dpc_measure(steps)
step_numbers = list(range(1, steps + 1))

plt.figure(figsize=(12, 6))
plt.plot(step_numbers, measures, 'ro-', linewidth=2, markersize=6)
plt.xlabel('Construction Step k')
plt.ylabel('Total Measure Remaining')
plt.title('Measure Remaining in Dynamic Prime Cantor Set Construction')
plt.grid(True, alpha=0.3)
plt.yscale('log')  # Use log scale since measure approaches 0
plt.tight_layout()
plt.show()

print(f"Measure remaining after {steps} steps: {measures[-1]:.10f}")

Total measure remaining in the DPC set construction

Measure remaining after 15 steps: 0.0006167466

---

Fundamental Properties of the Dynamic Prime Cantor Set

The set \(S_\infty\) inherits several properties common to Cantor-like constructions, but with unique characteristics due to its prime-based definition.

Compactness and Non-emptiness

Each \(S_k\) is a finite union of closed intervals, hence closed and bounded (subset of \([0,1]\)), therefore compact. \(S_\infty\) is the intersection of a nested sequence of non-empty compact sets (\(S_{k+1} \subset S_k\)), and thus is itself non-empty and compact by Cantor’s Intersection Theorem.

Measure Zero Property

The DPC set has Lebesgue measure zero. This can be proven by showing that the sum \(\sum_{i=1}^\infty \frac{\pi(p_i)}{p_i+1}\) diverges, which follows from the Prime Number Theorem.

def calculate_critical_sum(terms=20):
    """Calculate the sum Σ π(p_i)/(p_i+1) for first n terms"""
    primes = sieve_of_eratosthenes(100)[:terms]
    sums = []
    running_sum = 0
    
    for i, p in enumerate(primes):
        pi_p = len(sieve_of_eratosthenes(p))
        term = pi_p / (p + 1)
        running_sum += term
        sums.append(running_sum)
    
    return sums

sums = calculate_critical_sum(20)
term_numbers = list(range(1, 21))

plt.figure(figsize=(12, 6))
plt.plot(term_numbers, sums, 'go-', linewidth=2, markersize=6)
plt.xlabel('Number of Terms')
plt.ylabel('Partial Sum Σ π(p_i)/(p_i+1)')
plt.title('Divergence of Critical Sum (Confirms Measure Zero Property)')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

print(f"Sum of first 20 terms: {sums[-1]:.4f}")

Verification of the divergence of the critical sum

Sum of first 20 terms: 7.2027

Hausdorff Dimension Approaching 1

One of the most remarkable properties of the DPC set is that despite having measure zero, its Hausdorff dimension converges to 1. This is directly linked to the Prime Number Theorem.

def calculate_hausdorff_dimension_approx(n_steps=10):
    """Calculate approximation of Hausdorff dimension using the construction"""
    primes = sieve_of_eratosthenes(50)[:n_steps]
    dimensions = []
    
    cumulative_intervals = 1
    cumulative_scaling = 1
    
    for i in range(n_steps):
        p = primes[i]
        pi_p = len(sieve_of_eratosthenes(p))
        
        # Number of intervals after this step
        intervals_factor = p + 1 - pi_p
        cumulative_intervals *= intervals_factor
        
        # Scaling factor after this step (inverse)
        scaling_factor = p + 1  # Each interval gets divided by this factor
        cumulative_scaling *= scaling_factor
        
        # Dimension approximation = log(N) / log(1/r) where N is number of pieces and r is scaling ratio
        if cumulative_intervals > 1 and cumulative_scaling > 1:
            dim = np.log(cumulative_intervals) / np.log(cumulative_scaling)
            dimensions.append(dim)
        else:
            dimensions.append(0)
    
    return dimensions

dimensions = calculate_hausdorff_dimension_approx(15)
step_numbers = list(range(1, 16))

plt.figure(figsize=(12, 6))
plt.plot(step_numbers, dimensions, 'bo-', linewidth=2, markersize=6, label='Computed dimension')
plt.axhline(y=1, color='r', linestyle='--', label='Dimension = 1 (Asymptotic limit)', linewidth=2)
plt.xlabel('Construction Step k')
plt.ylabel('Hausdorff Dimension Approximation')
plt.title('Hausdorff Dimension Convergence to 1 for Dynamic Prime Cantor Set')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

print(f"Dimension after {len(dimensions)} steps: {dimensions[-1]:.4f}")

Hausdorff dimension approximation through construction steps

Dimension after 15 steps: 0.8259

The fact that the Hausdorff dimension approaches 1, despite the set having measure zero, is remarkable. It indicates that \(S_\infty\) is “thick” or “dense” enough to fill space dimensionally like a line, even though it contains no line segments. This occurs because the proportion of material removed at step \(k\), \(\pi(p_k)/(p_k+1)\), goes to zero relatively quickly due to the Prime Number Theorem.

---

The Dynamic Nature and Prime Gap Analysis

The “dynamic” nature of the DPC set refers to how the construction rules change at every step based on the prime sequence. Let’s analyze how prime gaps affect the local structure:

def prime_gaps_analysis(n_primes=20):
    """Analyze prime gaps and their effect on the construction"""
    primes = sieve_of_eratosthenes(100)[:n_primes]
    gaps = [primes[i] - primes[i-1] for i in range(1, len(primes))]
    
    # Calculate π(p_i) for each prime
    pi_values = [len(sieve_of_eratosthenes(p)) for p in primes]
    
    # Calculate the proportion of intervals kept at each step
    proportions_kept = [(p + 1 - pi_p) / (p + 1) for p, pi_p in zip(primes, pi_values)]
    
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
    
    # Plot prime gaps
    ax1.bar(range(1, len(gaps)+1), gaps, alpha=0.7, color='coral')
    ax1.set_xlabel('Prime Number Index')
    ax1.set_ylabel('Prime Gap Size')
    ax1.set_title('Prime Gaps for First 20 Primes')
    ax1.grid(True, alpha=0.3)
    
    # Plot proportion of intervals kept
    ax2.plot(range(1, len(proportions_kept)+1), proportions_kept, 'go-', linewidth=2, markersize=6)
    ax2.set_xlabel('Construction Step k')
    ax2.set_ylabel('Proportion of Intervals Kept')
    ax2.set_title('Proportion of Intervals Kept at Each Step')
    ax2.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    return gaps, proportions_kept

gaps, proportions = prime_gaps_analysis()

Analysis of prime gaps and their effect on DPC construction

The prime gaps introduce a “breathing” rhythm to the DPC construction. If a gap is large, the structure defined by \(p_k\) (with its specific subdivision \(p_k+1\) and removal \(\pi(p_k)\)) persists through many potential integer subdivisions before the next prime \(p_{k+1}\) imposes its new, finer rule.

---

Hyperbolic Geometry Embedding Visualization

The intricate, infinitely refining structure of the DPC set finds a natural geometric interpretation within hyperbolic space. We can visualize the Poincaré disk model where the DPC set corresponds to a fractal subset on the boundary circle.

def poincare_disk_visualization():
    """Create a visualization of the Poincaré disk model"""
    fig, ax = plt.subplots(1, 1, figsize=(10, 10))
    
    # Draw the unit circle (boundary of Poincaré disk)
    unit_circle = plt.Circle((0, 0), 1, color='black', fill=False, linewidth=2)
    ax.add_patch(unit_circle)
    
    # Add some sample points on the boundary for DPC set
    n_points = 50
    angles = np.random.uniform(0, 2*np.pi, n_points)
    # Create a fractal-like distribution by clustering some points
    fractal_angles = []
    for i in range(20):  # Add clusters of points
        center_angle = np.random.uniform(0, 2*np.pi)
        cluster_size = np.random.randint(3, 8)
        cluster_angles = np.random.normal(center_angle, 0.3, cluster_size)
        fractal_angles.extend(cluster_angles)
    
    # Limit range and add some random points
    fractal_angles = np.array(fractal_angles) % (2 * np.pi)
    all_angles = np.concatenate([fractal_angles, np.random.uniform(0, 2*np.pi, 10)])
    
    # Plot points on the boundary
    x_boundary = np.cos(all_angles)
    y_boundary = np.sin(all_angles)
    ax.scatter(x_boundary, y_boundary, c='red', s=30, alpha=0.7, label='DPC Set Points')
    
    # Draw some geodesics (circular arcs orthogonal to boundary)
    for i in range(5):
        # Choose two random points on the boundary
        angle1, angle2 = np.random.choice(all_angles[:20], 2, replace=False)
        x1, y1 = np.cos(angle1), np.sin(angle1)
        x2, y2 = np.cos(angle2), np.sin(angle2)
        
        # Calculate center and radius of the geodesic arc
        # The geodesic is a circle orthogonal to the unit circle
        # This is a simplified representation
        ax.plot([0, x1], [0, y1], 'b--', alpha=0.3, linewidth=1)
        ax.plot([0, x2], [0, y2], 'b--', alpha=0.3, linewidth=1)
    
    ax.set_xlim(-1.2, 1.2)
    ax.set_ylim(-1.2, 1.2)
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3)
    ax.set_title('Poincaré Disk Model: Dynamic Prime Cantor Set on Boundary')
    ax.legend()
    plt.tight_layout()
    plt.show()

poincare_disk_visualization()

Simplified visualization of the Poincaré disk model for DPC set

The Poincaré disk model provides a framework where the infinite nature of the construction and the limit set coexist within a finite model. The boundary \(\partial\mathbb{D}\) represents points at infinity, with the DPC set corresponding to a fractal subset of points on this boundary circle.

---

Discussion and Significance

The Dynamic Prime Cantor set is more than just another variation on Cantor’s theme. Its significance lies in several key aspects:

• Intrinsic Prime Connection: It is fundamentally a geometric object defined by the primes. Its properties are direct consequences of number-theoretic results like the PNT. It serves as a visualization of the prime sequence’s complexity.

• Complexity from Simple Rules: While the step-by-step rule is complex because it relies on primes, the overall framework is a straightforward iterative construction. This highlights how deep mathematical structure (primes) can generate geometric complexity.

• Richness Beyond Standard Cantor: The dynamic rule, the varying density controlled by prime gaps, and the dimension 1 property make it structurally richer and more complex than its static counterpart.

• Interdisciplinary Bridge: It naturally connects number theory (primes, PNT), fractal geometry (Cantor sets, Hausdorff dimension), analysis (measure theory, limits), and hyperbolic geometry (boundary representations, geodesic trees).

The construction, especially visualized through its first few steps or via the hyperbolic tree, offers compelling ways to teach concepts in fractals, number theory, and non-Euclidean geometry. The idea of a fractal “breathing” with the primes is intuitively appealing.

---

Future Directions and Open Questions

The DPC set opens numerous avenues for further investigation:

• Rigorous Proofs: While the properties outlined here are strongly suggested by the construction and standard fractal analysis techniques, rigorous proofs for aspects like total disconnectedness and the precise convergence of the dimension formula require careful analytical treatment.

• Quantitative Analysis: Can we quantify the effect of prime gaps (e.g., large gaps like those after Maier primes) on the local dimension or porosity of the set? How does the set’s structure reflect known irregularities in prime distribution?

• Multifractal Properties: Does the set exhibit multifractal properties? Are there variations in scaling behaviour across different parts of the set?

• Alternative Constructions: What if different prime-based rules were used? For example, removing intervals indexed by composite numbers, or using \(p_k^2\) subdivisions, or incorporating twin primes?

The DPC set stands as a testament to the profound and often unexpected connections within mathematics. By replacing the simple, static rule of the classic Cantor set with a dynamic process governed by the sequence of prime numbers, we generate a fractal object of remarkable complexity. It is a set that is simultaneously sparse (zero measure) yet fills space dimensionally like a line (dimension 1). It is totally disconnected yet perfect, with points clustering arbitrarily closely. Its structure breathes in response to the primes, encoding aspects of their mysterious distribution.

---

Conclusion: Geometry Listening to Arithmetic

The Dynamic Prime Cantor set stands as a testament to the profound and often unexpected connections within mathematics. It offers a compelling example of how fundamental arithmetic structures can sculpt geometric reality. The Dynamic Prime Cantor set is not merely constructed; it is discovered at the confluence of number theory and fractal geometry, inviting further exploration into its depths and its potential to reveal more about the enduring enigma of the primes.

Asymptotic Analysis of the Hausdorff Dimension

Let \(p_k\) be the \(k\)-th prime and write \[N_k=\prod_{i=1}^k\big((p_i+1)-\pi(p_i)\big),\qquad S_k=\prod_{i=1}^k(p_i+1).\] The finite-step similarity-dimension is \[d_k=\frac{\ln N_k}{\ln S_k} =1-\frac{\sum_{i=1}^k \big[-\ln\big(1-\tfrac{\pi(p_i)}{p_i+1}\big)\big]}{\sum_{i=1}^k\ln(p_i+1)}.\]

Using \(\pi(p_i)\sim p_i/\ln p_i\) and \(-\ln(1-x)\sim x\) for small \(x\), we get the leading correction: \[1-d_k \approx \frac{\sum_{i=1}^k \frac{\pi(p_i)}{p_i+1}}{\sum_{i=1}^k\ln(p_i+1)} \sim \frac{\sum_{i=1}^k \frac{1}{\ln p_i}}{\sum_{i=1}^k \ln p_i}.\]

Using the standard prime asymptotic \(p_i\sim i\ln i\), so \(\ln p_i\sim\ln i\), then: \[\sum_{i=1}^k \frac{1}{\ln p_i}\sim\frac{k}{\ln k},\qquad \sum_{i=1}^k \ln p_i\sim k\ln k,\] hence \[1-d_k \sim \frac{k/\ln k}{k\ln k}=\frac{1}{(\ln k)^2}.\]

Double-Logarithmic Behavior in Geometric Scale

If we describe things by the geometric resolution \(\varepsilon_k\) (typical interval length after \(k\) steps), \[\varepsilon_k \sim \prod_{i=1}^k\frac{1}{p_i+1}\quad\Rightarrow\quad \ln\frac{1}{\varepsilon_k}\sim\sum_{i=1}^k\ln p_i\sim k\ln k.\]

Solving roughly for \(k\) in terms of \(\varepsilon\): \[k\sim \frac{\ln(1/\varepsilon)}{\ln\ln(1/\varepsilon)}.\]

Substituting into the \(1/(\ln k)^2\) formula: \[1-d_k \sim \frac{1}{\big(\ln k\big)^2} \sim \frac{1}{\big(\ln\ln(1/\varepsilon)\big)^2},\]

so the deficit decays as an inverse square of a double log of the resolution. This is the double-logarithmic claim: expressed in terms of scale \(\varepsilon\) (or total subdivision size), convergence to 1 is controlled by powers of \(\ln\ln(1/\varepsilon)\).

import numpy as np

def calculate_asymptotic_correction(k_values):
    """Calculate the theoretical asymptotic correction 1-d_k ≈ 1/(ln k)²"""
    corrections_theory = [1.0 / (np.log(k)**2) if k > 1 else np.nan for k in k_values]
    return corrections_theory

# Use the same data from earlier calculation
k_values = list(range(2, 16))  # From 2 to 15
corrections_theory = calculate_asymptotic_correction(k_values)

# Plot the 1-d_k values from our earlier computation
computed_dimensions = calculate_hausdorff_dimension_approx(15)[1:]  # Skip first step
complement_computed = [1.0 - d for d in computed_dimensions]

plt.figure(figsize=(12, 6))
plt.loglog(k_values, complement_computed, 'bo-', label='Computed 1-d_k', linewidth=2, markersize=6)
plt.loglog(k_values, corrections_theory, 'r--', label='Theoretical 1/(ln k)²', linewidth=2)
plt.xlabel('Construction Step k')
plt.ylabel('|1 - d_k|')
plt.title('Convergence of Hausdorff Dimension: Computed vs Theoretical Asymptotics')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

print(f"Theoretical correction for k=15: {corrections_theory[-1]:.6f}")
print(f"Computed complement for k=15: {complement_computed[-1]:.6f}")

Convergence of Hausdorff dimension to 1 with double-logarithmic behavior

Theoretical correction for k=15: 0.136360
Computed complement for k=15: 0.174146

Intuition Recap

• The proportion removed at step \(i\) is about \(1/\ln p_i\) (Prime Number Theorem), which is small and slowly decaying.
• Cumulatively those tiny removals are enough to kill Lebesgue measure (because \(\sum 1/\ln p_i\) diverges), but not strong enough to push the Hausdorff dimension below 1.
• The slowness of \(1/\ln p_i\) is the source of the double-log appearance once you move from step count to geometric resolution.

Practical Considerations

• Both descriptions are important: (i) the \(1/(\ln k)^2\) rate in terms of step \(k\), and (ii) the double-logarithmic form in terms of resolution \(\varepsilon\). These provide complementary perspectives on the convergence behavior.
• The rigorous claim is: “converges to 1; asymptotic deficit \((1-d_k)=O((\ln k)^{-2})\)). Equivalently, in geometric scale \(\varepsilon\), \((1-d)=O((\ln\ln(1/\varepsilon))^{-2})\)). Full rigorous bounds require tracking PNT error-terms (left for a longer note).”

---

References

• Falconer, K. (2014). Fractal Geometry: Mathematical Foundations and Applications. Wiley.
• Mandelbrot, B. B. (1982). The Fractal Geometry of Nature. W. H. Freeman.
• Hardy, G. H., & Wright, E. M. (2008). An Introduction to the Theory of Numbers. Oxford University Press.
• Apostol, T. M. (1976). Introduction to Analytic Number Theory. Springer.
• Beardon, A. F. (1983). The Geometry of Discrete Groups. Springer.

---

ShunyaBar Labs conducts interdisciplinary research at the intersection of number theory, fractal geometry, and mathematical physics, exploring fundamental mathematical structures that underlie complex systems.