The main objectives of the polymath8 project, initiated by Terry Tao back in June, were “to understand the recent breakthrough paper of Yitang Zhang establishing an infinite number of prime gaps bounded by a fixed constant 
Polymath8 was a remarkable success! Within two months the best value of H that was 70,000,000 in Zhang’s proof was reduced to 5,414. Moreover, the polymath setting looked advantageous for this project, compared to traditional ways of doing mathematics. (I have written a post with some more details and thoughts about it, looked from a distance.)
The polymath blog 
The link to the paper of Yitang Zhang shows “page not found”.
Click to access YitangZhang.pdf
[Updated, thanks – T.]
Comment by KM Tu (@kmtutu) — May 19, 2014 @ 3:52 pm |
how to lo
Comment by Ignora (Not revealing my name) — September 17, 2024 @ 11:24 am |
so ya‘ll ummm, imma send a work me and my friend have been working on lately. Its about the Twin Prime Conjecture. Corrections are appreciated, please email me on my email: minecraftlex797@gmail.com if there are anything you want me to clarify or correct, or even revise this paper. This paper does not constitute any formal proof but does include Empirical, Theoretical and Heuristic Arguments. Thanks!
Twin Prime Conjecture: Empirical and Theoretical Stuff
Twin Prime Conjecture: An Empirical Analysis
Contributors:
• Ignora: Main work, research, and mathematics
• itsjakeadventure2017: Thinking, ideas, and research assistance
Disclaimer: Before delving into this paper, please be aware that some parts, particularly the formulas, might contain errors. Your corrections are appreciated. Also, some of the scripts shown may require installing external libraries. Thank you!
Definition of Terms:
Twin Prime- A pair of primes separated by 2 (p, p+2).
Bounded Gap- The difference between consecutive primes constrained by a fixed upper limit.
Twin Prime Conjecture- A conjecture in number theory that says that there are an infinite number of twin primes.
Conjecture- Complex statements that do not have the proof/axioms to be considered true.
The Twin Prime Conjecture (OVERVIEW)
Abstract: The Twin Prime Conjecture posits that there are infinitely many twin primes—pairs of prime numbers that differ by exactly 2, such as (3, 5), (5, 7), (11, 13), and (17, 19). Despite extensive efforts, a definitive proof remains elusive due to the inherent complexity and incomplete understanding of mathematics. This conjecture remains one of the most intriguing unsolved problems in number theory. In this paper, we will discuss about this tricky problem using heuristic, theoretical, and empirical methods. The empirical methods used here were employed because of their uses in the study of prime numbers.
Conclusion: The empirical analysis of the Twin Prime Conjecture demonstrates that twin primes are prevalent across various ranges and computational limits. Through the use of advanced algorithms and parallel processing, we have confirmed the existence of numerous twin primes, reinforcing the conjecture’s claim of their seemingly infinite nature. While empirical data strongly supports the conjecture, these observations remain inconclusive without a formal proof. Future research leveraging more sophisticated algorithms and greater computational resources may further illuminate the behavior of twin primes and their distribution.
Theoretical Insight: Theory of Infinitude (THEORETICAL)
In the realm of numbers, the set of possible values is infinite. For example, starting with 1 and adding zeros results in values like 10, 100, and eventually a googolplex. This notion implies that if the universe of numbers is infinite, then the possibility of infinitely many twin primes exists. However, proving this conjecture may require advanced computational tools or extensive calculations due to its complexity. But, with the use of set theory, we can theoretically say there are an infinite number of twin primes because in set theory, an infinite set P (the set of all primes), can also have an infinite subset TP (the set of all twin primes). With this set theory in mind, one could hypothesize there are indeed an infinite number of twin primes.
Conclusion: The theoretical exploration of the Twin Prime Conjecture, grounded in set theory and the nature of infinite sets, provides a compelling argument for the existence of infinitely many twin primes. By leveraging set theory, we can hypothesize that the set of twin primes is an infinite subset of the infinite set of primes. Although this theoretical framework supports the conjecture, a rigorous proof remains elusive. Theoretical advancements and deeper insights into number theory will be crucial for bridging the gap between conjecture and proof.
Computational Analysis (EMPIRICAL)
Twin Prime Generation Script (Python): The following Python script generates twin primes using various algorithms and parallel processing techniques:
import multiprocessing This function is used to show twin primes up to a given range. Function to perform Sieve of Eratosthenes to find all primes up to n
def sieve_of_eratosthenes(n):
is_prime = [True] * (n + 1)
p = 2
while (p * p <= n):
if is_prime[p] == True:
for i in range(p * p, n + 1, p):
is_prime[i] = False
p += 1
primes = [p for p in range(2, n + 1) if is_prime[p]]
return primes Miller-Rabin Primality Test for large numbers
def miller_rabin(n, k=5):
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0:
return False
def _is_composite(a, d, n): if pow(a, d, n) == 1: return False for i in range(s): if pow(a, 2**i * d, n) == n - 1: return False return True d = n - 1 s = 0 while d % 2 == 0: d //= 2 s += 1 for _ in range(k): a = 2 + (n - 4) * int.from_bytes(os.urandom(1), 'big') // 256 if _is_composite(a, d, n): return False return TrueSegmented Sieve to find primes in a rangedef segmented_sieve(low, high, small_primes):
size = high – low + 1
is_prime = [True] * size
for prime in small_primes:
start = max(prime * prime, low + (prime – low % prime) % prime)
for j in range(start, high + 1, prime):
is_prime[j – low] = False
if low == 1:
is_prime[0] = False
return [i for i in range(low, high + 1) if is_prime[i – low]] Function to find twin primes in a given range
def find_twin_primes(low, high):
limit = int(high**0.5) + 1
small_primes = sieve_of_eratosthenes(limit)
primes = segmented_sieve(low, high, small_primes) twin_primes = [] for i in range(len(primes) - 1): if primes[i + 1] - primes[i] == 2: twin_primes.append((primes[i], primes[i + 1])) return twin_primesWrapper function for parallel processingdef parallel_find_twin_primes(low, high, num_chunks):
chunk_size = (high – low + 1) // num_chunks
chunks = [(low + i * chunk_size, low + (i + 1) * chunk_size – 1) for i in range(num_chunks)]
chunks[-1] = (chunks[-1][0], high) # Ensure last chunk goes up to high
with multiprocessing.Pool(num_chunks) as pool: results = pool.starmap(find_twin_primes, chunks) twin_primes = [tp for result in results for tp in result] return twin_primesMain function to run the scriptif name == “main“:
import os # os.urandom for randomness in Miller-Rabin
low = 1
high = 1000000
num_chunks = 8
twin_primes = parallel_find_twin_primes(low, high, num_chunks) for tp in twin_primes: print(tp)This script uses:
• Sieve of Eratosthenes for initial prime generation.
• Miller-Rabin Primality Test for larger numbers.
• Segmented Sieve for range-specific prime finding.
• Parallel Processing for efficiency.
Riemann-Zeta Function Script (Python)(EMPIRICAL):
The Riemann-Zeta helps in understanding the distribution of primes and if combined with sieve methods and more, it could help close the gap. The Riemann-Zeta function helps in understanding the distribution of primes:
def zeta(s, terms=1000000):
if s <= 1:
raise ValueError(“s must be greater than 1”)
return sum(1.0 / (n ** s) for n in range(1, terms + 1))Example usageif name == “main“:
s = 2
terms = 1000000
result = zeta(s, terms)
print(f”Approximation of zeta({s}) with {terms} terms: {result}”)
Additional Functions
Dirichlet L Function (Python):
Helps us approximate the distribution of primes. Its very useful in this case because it would help approximate the distribution of primes and in this case, possibly help us close the gap.
def is_prime(n):
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def dirichlet_l_function(s, num_terms=100):
total = 0.0
count = 0
num = 2
while count < num_terms: if is_prime(num): total += 1 / (num ** s) count += 1 num += 1 return totalExample usages = 2.0
num_terms = 50
result = dirichlet_l_function(s, num_terms)
print(f”L(s) = {result}”)
Chebyshev Function (Python)(EMPIRICAL):
Helps in prime distribution analysis
def is_prime(n):
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def prime_sieve(limit):
is_prime_list = [True] * (limit + 1)
p = 2
Von Mangoldt Function (EMPIRICAL)
Helps in the study of prime numbers. The Von Mangoldt Function is very useful in this case because it will help us deepen our understanding of prime numbers.
def is_prime(n):
“””Check if a number is prime.”””
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def is_power_of_prime(n):
“””Check if n is a power of a prime number.”””
if n <= 1:
return False
# Check for prime powers for p in range(2, int(n**0.5) + 1): if is_prime(p): power = p while power <= n: if power == n: return p power *= p return n if is_prime(n) else 0def log(x):
“””Approximate the natural logarithm of x using a series expansion.”””
if x <= 0:
return float(‘-inf’) # Logarithm of non-positive numbers is undefined.
if x == 1:
return 0.0
result = 0.0
term = (x – 1) / (x + 1)
current = term
n = 1
while current != 0:
result += current / n
n += 2
current *= term * term
return 2 * result
def von_mangoldt(n):
“””Compute the von Mangoldt function value for a given n.”””
if n < 1:
return 0
p = is_power_of_prime(n) if p: return log(p) return 0def generate_twin_primes(limit):
“””Generate twin primes up to a given limit.”””
twin_primes = []
for num in range(2, limit – 1):
if is_prime(num) and is_prime(num + 2):
twin_primes.append((num, num + 2))
return twin_primes
def main():
limit = int(input(“Enter the limit for generating twin primes: “))
twin_primes = generate_twin_primes(limit)
if twin_primes: print("Twin primes up to", limit, ":") for pair in twin_primes: print(pair) else: print("No twin primes found up to", limit) n = int(input("Enter a number to compute the von Mangoldt function: ")) vm_value = von_mangoldt(n) print(f"Λ({n}) = {vm_value}")if name == “main“:
main()
Infinite JS Generator (EMPIRICAL)
This snippet says Yes if there is atleast 1 prime pair every 5 numbers, and No if otherwise. This code, if used on a supercomputer or just a good computer, could prove the infinite number of twin primes.
function isPrime(n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 === 0 || n % 3 === 0) return false;
let i = 5;
while (i * i <= n) {
if (n % i === 0 || n % (i + 2) === 0) return false;
i += 6;
}
return true;
}
function checkTwinPrimesWithinRange(start, end) {
for (let i = start; i <= end – 2; i++) {
if (isPrime(i) && isPrime(i + 2)) {
return true;
}
}
return false;
}
let current = 1;
function detectTwinPrimes() {
setInterval(() => {
let end = current + 4; // We check numbers from
currenttocurrent + 4if (checkTwinPrimesWithinRange(current, end)) {
console.log(“Yes”);
} else {
console.log(“No”);
}
current++;
}, 1000); // Check every second to avoid flooding the console
}
// Start the detection
detectTwinPrimes();
Mathematical Formula used here:

isPrime(n)={ True if n > 1 and ∀d (2 is less than or equal to d is less than or equal to square root of n) such that n mod d is not equal to 0
{ False otherwise
Conclusion: The computational analysis of twin primes, utilizing Python scripts and advanced algorithms, has successfully generated and identified twin primes across large numerical ranges. Techniques such as the Sieve of Eratosthenes, Miller-Rabin Primality Test, and segmented sieves, combined with parallel processing, have proven effective in handling large datasets. This computational approach not only provides empirical evidence for the conjecture but also highlights the need for continued refinement of algorithms to manage increasingly larger numerical ranges and to approach the conjecture from new angles.
Heuristic Insight (HEURISTIC+THEORETICAL)
• Empirical Evidence: Calculations up to very high limits (e.g., billions or trillions) have consistently found twin primes, supporting the idea that they may continue infinitely.
• Distribution Patterns: Twin primes appear less frequently as numbers grow larger, but they still appear, consistent with the Prime Number Theorem.
• Prime Number Theorem: Indicates that primes become less frequent but do not vanish, suggesting twin primes will continue to appear, though less frequently.
• Twin Prime Heuristic: The density of twin primes decreases roughly as 1/log2(n) . This decreasing trend supports the idea of infinite twin primes without approaching zero quickly.
• Chen’s Theorem: Supports the broader context that primes (and related prime pairs) do not vanish.
• Yitang Zhang’s Work: Shows that there are infinitely many pairs of primes with bounded gaps, indirectly supporting the idea of the infinity of twin primes.
Conclusion: Heuristic insights into the Twin Prime Conjecture, supported by historical data and probability models, offer a valuable perspective on the distribution and density of twin primes. The Prime Number Theorem and various heuristics suggest that while twin primes become less frequent as numbers grow larger, they do not vanish. The application of these probabilistic models reinforces the notion of an infinite number of twin primes, though they also emphasize the challenges in proving the conjecture conclusively. Continued exploration in heuristic methods and probabilistic models remains essential for advancing our understanding of prime distributions.
Patterns (EMPIRICAL)
Twin Primes Observation:
• Range 1-88: Twin primes include (3, 5), (5, 7), (11, 13), (17, 19), (29, 31), (41, 43), (59, 61), (71, 73).

• Range 89-200: Twin primes include (101, 103), (107, 109), (137, 139), (179, 181), (197, 199).
Output Example (200-300):
Using the twin prime generator script in the range 200-300 shows that the gaps between twin primes grow larger. But that doesn’t mean that they are finite, that they are going to vanish at a certain point.

Using a generator, the twin primes ranging from 2500 until 4000 are listed here. While the gap between the two ranges may be in the hundreds but they are still abundant. (e.g 2591 and 2687‘s gap is 96)(2687 and 2729‘s gap is 42)

Conclusion: The analysis of patterns in twin primes reveals that although the gaps between consecutive twin primes tend to increase, twin primes persist across extensive numerical ranges. The empirical observations indicate that twin primes remain abundant even at higher numerical limits, reinforcing the conjecture’s validity. The continued study of these patterns, including the examination of gaps and their variations, provides further support for the conjecture and highlights the ongoing need for detailed empirical and theoretical investigation.
Gaps (EMPIRICAL)
We can use this script to find bounded gaps
def find_bounded_prime_gaps(limit, gap):
is_prime = [True] * (limit + 1)
is_prime[0] = is_prime[1] = False
for start in range(2, int(limit**0.5) + 1): if is_prime[start]: for multiple in range(start*start, limit + 1, start): is_prime[multiple] = False primes = [num for num, prime in enumerate(is_prime) if prime] gaps = [(p1, p2) for p1, p2 in zip(primes, primes[1:]) if p2 - p1 == gap] return gapsExample usagelimit = 1000000
gap = 2
gaps = find_bounded_prime_gaps(limit, gap)
print(f”Prime pairs with gap {gap} up to {limit}:”)
for p1, p2 in gaps:
print(f”({p1}, {p2})”)
Conclusion: The investigation of bounded gaps between primes, particularly those of size 2, underscores the persistent nature of twin primes across large datasets. The identification of prime pairs with specific gaps helps in understanding the distribution of twin primes and supports the conjecture’s assertion of their potential infinitude. This analysis not only confirms the presence of twin primes within bounded gaps but also provides a framework for future research into the characteristics and distribution of prime gaps.
Possion Probabilistic Model For Prime Gaps (EMPIRICAL)
Its a script used for prime gaps.
import math
import matplotlib.pyplot as plt Function to generate primes up to a given limit using the Sieve of Eratosthenes
def generate_primes(limit):
sieve = [True] * (limit + 1)
sieve[0] = sieve[1] = False # 0 and 1 are not primes
for start in range(2, int(limit*0.5) + 1): if sieve[start]: for multiple in range(startstart, limit + 1, start):
sieve[multiple] = False
return [num for num, is_prime in enumerate(sieve) if is_prime] Function to calculate gaps between consecutive primes
def calculate_gaps(primes):
return [primes[i+1] – primes[i] for i in range(len(primes) – 1)] Function to calculate the mean of a list
def mean(data):
return sum(data) / len(data) if data else 0 Function to calculate the Poisson probability mass function (PMF)
def poisson_pmf(k, lambd):
return (lambd ** k * math.exp(-lambd)) / math.factorial(k) Parameters
limit = 100000 Generate primes and gaps
primes = generate_primes(limit)
gaps = calculate_gaps(primes) Estimate lambda (mean of gaps)
lambda_estimate = mean(gaps) Prepare for plotting
max_gap = max(gaps)
gap_range = range(1, max_gap + 1)
pmf = [poisson_pmf(k, lambda_estimate) for k in gap_range] Histogram of observed gaps
gap_counts = [gaps.count(i) for i in gap_range]
total_gaps = len(gaps)
observed_probabilities = [count / total_gaps for count in gap_counts] Plotting
plt.hist(gaps, bins=range(1, max_gap + 2), density=True, alpha=0.6, label=’Observed gaps’)
plt.plot(gap_range, pmf, ‘ro-‘, label=f’Poisson fit (λ={lambda_estimate:.2f})’)
plt.xlabel(‘Gap Size’)
plt.ylabel(‘Probability’)
plt.title(‘Distribution of Gaps Between Primes’)
plt.legend()
plt.show()
Conclusion: The Poisson probabilistic model applied to prime gaps offers a statistical perspective on the distribution of gaps between primes. By comparing observed gaps with Poisson distributions, we gain insights into the expected frequency of various gap sizes. This approach reinforces the idea that while gaps between primes vary, their distribution follows predictable patterns. The application of such models aids in understanding the behavior of prime gaps and supports the ongoing investigation into the Twin Prime Conjecture.
A Sliver of Reasoning (THEORETICAL + HEURISTIC)
So, lets say we have an infinite set P, the set of all primes. In set theory, an infinite set, can also have an infinite subset. So lets say our set, P, has a subset TP, the set of all twin primes. So, it means that there are infinite twin primes because of this one idea in set theory. While a heuristic insight/argument, this can serve as a framework, but this remains speculative.
Conclusion: The theoretical reasoning based on set theory provides a speculative yet intriguing framework for the Twin Prime Conjecture. By positing that the set of twin primes could be an infinite subset of the infinite set of primes, this reasoning supports the conjecture’s claim of infinitude. While this approach offers a valuable heuristic perspective, it remains speculative without concrete proof. Continued exploration and formal proofs are necessary to validate this theoretical reasoning and to advance our understanding of twin primes.
Conclusion
The Twin Prime Conjecture remains a captivating and unresolved problem in mathematics. Through a blend of empirical analysis, theoretical insights, computational techniques, and heuristic models, we gain a multifaceted understanding of twin primes and their distribution. Despite significant progress, the quest for a formal proof continues. Future research will need to integrate these diverse approaches to address the conjecture fully and potentially uncover new mathematical insights.
These conclusions tie together each section’s findings and highlight the ongoing challenges and future directions in studying the Twin Prime Conjecture.
References
Yitang Zhang- Bounded Gaps between Primes- The study of gaps between consecutive primes.
Wikipedia- Infinite Set- Assistance in set theory, Dirichlet L Function, Poisson Probabilistic Model, Riemann Zeta Function, etc.
Comment by Anonymous — September 17, 2024 @ 11:30 am |
also by the way, this paper was made by Ignora (me.) im on an alt.
Comment by Anonymous — September 17, 2024 @ 11:31 am |
Good day Ignorum. -?
Comment by Anonymous — September 19, 2024 @ 7:51 am |
nigga
Comment by Anonymous — September 19, 2024 @ 7:53 am |
Comment by Anonymous — September 23, 2024 @ 12:42 am |