Version 49 of Twin Primes Follow up with Pseudocode Study and TCL 8.6 demo example calculator, numerical analysis

This page is under development. Comments are welcome, but please load any comments in the comments section at the bottom of the page. Please include your wiki MONIKER and date in your comment with the same courtesy that I will give you. Aside from your courtesy, your wiki MONIKER and date as a signature and minimal good faith of any internet post are the rules of this TCL-WIKI. Its very hard to reply reasonably without some background of the correspondent on his WIKI bio page. Thanks, gold 3/8/2024

• • Twin Primes Follow up with Pseudocode Study
  • Preface
  • Introduction
  • Not a Replacement for TCL Core
  • Body
  • Draft Outline for Applications of Primes including Twin Primes
  • Extension of Historical Gauss, Legendre, and Modified_Legendre approximations
  • Pseudocode on listPrimePairs
  • Math Template Subroutine for study here
  • Gaps between Twin Primes, What expected?
• Table: Rarity of Primes as percent reported from Modified_Legendre_primes function
  • References:
  • Extra Credit on One Line Procedures
  • Screenshots Section
    • figure 1. Slow Series Convergence for Brun Constant
    • figure 1a. Bruns constant in lower primes field
    • figure 1c. Bruins constant series
    • figure 2.
    • figure 3.
    • figure 4.
    • figure 5.
    • figure 6.
    • figure 7.
    • figure 8.
    • figure 9.
    • figure 10.
    • figure 11.
    • figure 12.
  • Auxiliary Code Under Test
• Hidden Comments Section

Twin Primes Follow up with Pseudocode Study

Preface

gold Update 3/7/2024. The Twin Primes procedure is loaded on the Tcllib math::primes module. Reference Routines are listPrimePairs and listPrimeProgressions on Tcllib. Study of Twin Primes features using pseudocode. Console program outputs data as table in TCL table format and comma delimited spreadsheet. These auxiliary decks are used to proof features or subroutines. The Monopoly page from GWM seems closest in theme to what I was trying to learn. Using dice and running with random throws along a track or path like Snakes and Ladders.

gold Update 3/7/2024. The author is retired engineer on Windows 10 and no longer has proofing access to Unix machines. Unix is respected after use of so many decades in engineering, but my wings are lost. I did find a useful online IDE, jdoodle. I can paste from a text file, edit, and run an output using this online IDE.

gold Note: Some tickets for prime numbers are closed and functions available in Tcllib. Many thanks to Arjen Markus arjen AM & Andreas Kupries for the heavy lifting.

closer: arjenmarkus AM

Emailed comment from AM: I used the sample code to create two new procedures:

  listPrimePairs 
  listPrimeProgressions

The first proc listPrimePairs returns a list of pairs of primes that differ by a given number and the second proc listPrimeProgressions returns a list of arithmetic progressions of primes that differ by the given number.

Introduction

Not a Replacement for TCL Core

This page on developing pseudocode examples and one line procedures is not a replacement for the current Tcl core and Tcllib, which is much improved since Tcl version 4, and other <faster> language constructs. math ops, Tcllib routines, and other compiled routines can reduce the cost of big-data tasks by about 1/3. The time savings of the core are not always obvious on small quantities of data, like 4 or 5 numbers. Performance of one-line programs may suffer degradation due to lengthy recursion calls, and may be limited by constraints on recursion. Dependence on math operator notation, helper procedures, math check examples, degradation due to lengthy recursion calls, and special library functions should be noted in the comment lines.

gold 3/8/2024 Draft & Check.

Body

Draft Outline for Applications of Primes including Twin Primes

1. Cryptography: Primes play a crucial role in encryption algorithms such as RSA (Rivest-Shamir-Adleman), which relies on the difficulty of factoring large numbers into their prime components to secure communication online.

2. Number theory: Primes are fundamental in number theory, the branch of mathematics that studies the properties and relationships of numbers. Studying prime numbers helps to understand the distribution of primes, prime factorization, and other important concepts in mathematics.

3. Primality testing: Algorithms have been developed to efficiently determine whether a given number is prime. These algorithms are essential in various applications, such as programming languages, cryptography, and computer science.

4. Random number generation: Primes are often used in generating random numbers, especially in cryptographic applications where randomness is crucial for security. The use of prime numbers in random number generation ensures a higher level of unpredictability and security.

5. Error detection and correction: Primes are used in error detection and correction algorithms, such as the Reed-Solomon codes, which are commonly used in data storage and transmission systems. By leveraging the properties of prime numbers, these algorithms can detect and correct errors in transmitted data.

Twin primes, which are prime numbers that have a difference of 2 (e.g., 3 and 5, 11 and 13), have applications in number theory, cryptography, and computer science.

1. In number theory, the study of twin primes helps researchers understand the distribution of prime numbers.

2. In cryptography, twin primes are used in certain encryption algorithms.

3. In computer science, twin primes can be used in algorithms for generating random numbers.

Extension of Historical Gauss, Legendre, and Modified_Legendre approximations

Extension of Historical formulas. In an 1849 letter, Gauss discussed findings on the number of primes in various regions of the number line. The historical background of this prime number theory is of interest today in developing simple TCL routines. The Gauss approximation for number of primes is approx_number_primes = N1 / ln (N1), 15 percent average error. Gauss developed this formula at the age of 14! and formula was first published in 1863. If the exact solution is tabbed as one, the program is storing the exact solution in a list of limited size. The number one should not be counted as a prime and the number two is counted as prime, so some starting algorithm statements are tricky. The Legendre approximation for number of primes was approx_legendre_primes2 = N1 / (ln (N1)-1), 2 percent average error beyond 1E4. A variant of the Legendre equation was modified_legendre_primes3 = N1 / (ln (N1)-1.08366). In the modified Legendre error covering E6, no particular trends are seen leading from zero level, but there are some sawtooth patterns at intervals. Also the prime counting function is reported to have gaps between the primes, which might be difficult to see at this density.

in 1922, by Godfrey Harold Hardy (1877-1947) and John Edensor Littlewood (1885-1977) to estimate the density of twin primes. Starting with the Gauss approximation and the Hardy paper, the probability that a number n is prime is about 1/log(n). Therefore, if the probability that n+2 as a prospective twin prime is also prime was independent of the probability for n. The approximation for the prime density PI2 of twin primes PI2(n) ~~ n/(log(n)*log(n).

Extension. If one starts with the modified_legendre_primes3 = N1 / (ln (N1)-1.08366) and similar postulates as before. Then possibly an approximation for the twin prime density would be = N1 / ((ln (N1)-1.08366) * (ln (N1)-1.08366)) ? The extension formula could be developed into a one line procedure in TCL. The modified Legendre approximation reported about 28 primes from field of 0 to 100. The modified Legendre approximation reported about rounded 8 pairs of twin primes from field of 0 to 100. The Tcllib program reported 8 sets of twin primes over the interval of 100 as list of twin primes = {3 5} {5 7} {11 13} {17 19} {29 31} {41 43} {59 61} {71 73}.

# using mathop here in spots
#legendre_prime_density function might be  
proc  legendre_prime_density_approx {nn} {[/ 1. [- [log $nn 1.0866 ]] ] }
#   PI2(n) ~~ n/(log(n)*log(n)
# Under test, have to check syntax
# expr expression from Tcclib for legendre_tester  == expr {$limit / (log($limit) - 1.08366)}
# proc  legendre_tester {nn} { expr { 1./ ((log(n)*log(n)  )    }     }
#  
puts " legendre_tester [ legendre_tester 100 ]      "
#  legendre_tester 8.063843715007492 # approximation      

Pseudocode on listPrimePairs

# Pseudocode
# Procedure: listPrimePairs
# Note dependency here on Tcllib proc isprime
# Parameters:
#   lower - lower limit for the interval
#   upper - upper limit for the interval
#   step - difference between successive primes (default: 2)
# Return:
#   list of pairs of primes differing the given step

    # Procedure is_prime to check if a number is prime
    proc is_prime(n):
    if n < 2:
        return False
    for i from 2 to sqrt(n):
        if n % i == 0:
            return False
    return True

    # Procedure  listPrimePairs
    procedure listPrimePairs(lower, upper, step=2):

    # Validation card
    if upper <= lower:
        return error: "The upper limit must be larger than the lower limit"
    if step <= 0:
        return error: "The step must be at least 1"

    # Initialize output variable here, list in TCL
    output = []

    # for next loop in TCL
    for i in range(lower, upper+1):
        next = i + step
        if isPrime(i) and isPrime(next):
            output.append([i, next])

    return output

    End

Pseudocode generates a list of prime number pairs that differ by the given step within the specified interval. The pseudocode uses a similar logic to the original Tcllib script, with some minor modifications to match the pseudocode syntax.

# list from copy of [Tcllib] deck on jdoodle.
brun constant over selected range = 
series 1/5 + 1/7 + 1/11 + 1/13 + 1/17 + 1/19 + 1/29 + 1/31 + 1/41 + 1/43 + 1/59 + 1/61 = 0.7698738952
puts " list of twin primes = [ listPrimePairs 3 100 2 ] "
list of twin primes = {3 5} {5 7} {11 13} {17 19} {29 31} {41 43} {59 61} {71 73}
 brun constant over selected range  0.5333333333333333        
 brun constant over selected range  0.5333333333333333 
 brun constant over selected range  1.330990365719087        
 brun constant over selected range  1.330990365719087  
 puts " list of twin primes = [ listPrimePairs 3 500 2 ] "
 bruin constant over selected range  1.486060792020912 
 brun very slow closer and not much core allowance on jdoodle
 monograph = B2(p = 10**16) = 1.902160583104
 series converges extremely slowly.

Reference Testcases

Test Cases
P  ->  Partial Sum of series for Brun Constant
2 -> 0
6 -> 0.5333333333333333
10 -> 0.8761904761904762
13 -> 0.8761904761904762
100 -> 1.3309903657190867
620 -> 1.4999706034568274
100000 -> 1.67279958482774

p        B2(p) 
10E2        1.330990365719 
10E4        1.616893557432 
10E6        1.710776930804 
10E8        1.758815621067 
10E10        1.787478502719 
10E12        1.806592419175 
10E14        1.820244968130 
10E15        1.825706013240  
10E16        1.830484424658 

different more converging formula? 

Ref = Introduction to twin primes and Brun’s constant
computation
Pascal Sebah and Xavier Gourdon

  10^5:      1.90216329186       (   6.1 s)
  10^6:      1.90191335333       (  63.1 s)
  10^7:      1.90218826322       ( 759.6 s)
2*10^7:      1.90217962170       (1692.3 s)

B2(p = 10**16) => 1.902160583104

Math Template Subroutine for study here

Gaps between Twin Primes, What expected?

The first 60 prime gaps are:

1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2, 4, 14, 4, 6, 2, 10, 2, 6, 6, 4, 6, 6, 2, 10, 2, 4, 2, 12, 12, 4, 2, 4, 6, 2, 10, 6, 6, 6, 2, 6, 4, 2, ... (sequence A001223 in the OEIS).

The average gap between primes increases as the natural logarithm of these primes, and therefore the ratio of the prime gap to the primes involved decreases (and is asymptotically zero). This is a consequence of the prime number theorem. --- Wikipedia

Taking averages between prime pairs, the positions of 2. what expected?

mean   2, 4, 6, 6, 2,
mean   2, 4, 14, 4, 6, 2,
mean   2, 10, 6, 6, 6, 2
puts " math_mean = [math_mean 2  4  6  6  2  ]"  # 4
puts " math_mean = [math_mean  2  4  14  4  6, 2   ]"   # 5
puts " math_mean = [math_mean 2   10  6  6  6, 2  ]"    # 5

Table: Rarity of Primes as percent reported from Modified_Legendre_primes function

References:

Omitting outside links here, too transitory on internet.

• TCLLIB math::primes module
• Gauss Approximate Number of Primes and eTCL demo example calculator
• TCLLIB Current Release 1.21 (May 7, 2022)
• math::primes::isprime
• math::primes::firstNprimes
• math::primes::primesLowerThan
• math::primes::primeFactors
• math::primes::numberPrimesGauss
• math::primes::numberPrimesLegendre
• math::primes::numberPrimesLegendreModified
• math::primes::differenceNumberPrimesLegendreModified
• math::primes::numberPrimesLegendre N
• math::primes::numberPrimesLegendreModified N
• math::primes::differenceNumberPrimesLegendreModified lower upper
• math::primes::listPrimePairs lower upper step
• math::primes::listPrimeProgressions lower upper step
• Bruin's Constant at p=10**16 , B2(p = 10**16) = 1.902160583104..
• Ref = Introduction to twin primes and Brun’s constant computation
• Pascal Sebah and Xavier Gourdon
• On-Line Encyclopedia of Integer Sequences , OEIS
• Andrew Granville, Primes in intervals of bounded length, Joint Math Meeting, Jan 17 2014.
• J. C. Evard, Twin primes and their applications, archived Pdf
• James Maynard, Small gaps between primes, arXiv:1311.4600 , 2013, Annals of Mathematics,
• Godfrey Harold Hardy (1877-1947) and John Edensor Littlewood (1885-1977)
• to estimate the density of twin primes. historic approximate formula.
• many assumptions, p2(n) ~~ n / (log(n) * log(n)) , ref Gauss formula for prime number density.
• substantial interest online codegolf_
• stackexchange /questions/107634/approximate-bruns-constant
• sagemath twin_prime constant

    *The Twin Primes constant is defined as

• ∏︀ 1 − 1/(%F0%9D%91%9D − 1)**2
• for primes %F0%9D%91%9D > 2.

    *

• sage: float(twinprime)
• 0.6601618158468696
• sage: twinprime.n(digits=60)
• sage: 0.660161815846869573927812110014555778432623360284733413319448
• Improved bounds on Brun’s constant, Dave Platt, University of Bristol
• Enumeration to 1e14 of the twin primes and Brun's constant, Thomas R. Nicely

• Wikipedia: Gambler's Ruin
• Khan Academy: Gambler's Ruin
• MathWorld: Gambler's Ruin
• Wolfram Alpha: Gambler's Ruin Problem
• Quora: What are some practical applications of the Gambler's Ruin Problem?
• The Gambler's Ruin Problem" - Discrete Mathematics with Applications, by Kenneth Rosen:
• A chapter from the textbook explaining the Gambler's Ruin Problem
• and its applications in discrete mathematics
• "The Gambler's Ruin Problem: A Case Study in Probability" - MIT OpenCourseWare:
• A lecture on the Gambler's Ruin Problem
• "The Gambler's Ruin Problem" - Khan Academy: A video lesson explaining
• the Gambler's Ruin Problem and its applications in probability and statistics.

• Category Algorithm
• Gauss Approximate Number of Primes and eTCL demo example calculator
• Taking a Weighted Average, Dr Math, mathforum.org/dr.math, dated 03/20/2003
• google <Weighted Average, Dr Math>, mathforum.org/dr.math
• Using Weighted Criteria to Make Decisions, Dr Math>, mathforum.org/dr.math, dated 07/18/2008
• google <Weighted sum product model Decision >
• harmonic mean discussed in Additional math functions
• harmonic mean discussed in Tcl Normalized Extended Benchmarks
• see arithmetic mean on tcl-wiki Stats 2011-05-22, RLE
• see similar 1/(1/nth) terms method used in
• Babylonian Combined Market Rates and eTCL demo example calculator, numerical analysis

• GoDuck search engine < Functional Programming >
• GoDuck search engine < Imperative Programming >
• GoDuck search engine < Programming Examples >
• Google search engine < vaporware >
• Tcllib math::special Special mathematical functions
• Tcllib math::figurate Evaluate figurate numbers
• Tcllib simulation::random Pseudo-random number generators
• Tcllib simulation::montecarlo Monte Carlo simulations
• Wikipedia search engine < Lehmer random number generator >
• Professor Frisby's Mostly Adequate Guide to Functional Programming on internet archive
• Writing code using the Pseudocode Programming Process, article by David Zych
• Mathematical Methods in Large-scale Computing Units
• by Derrick H. Lehmer
• L’Ecuyer, Pierre (January 1999). "Tables of linear congruential generators of different sizes and good lattice structure"
• Mathematics of Computation. 68
• A Comprehensive Review of Quantum Random Number PDF
• Good Pedagogical Random Number Generators
• from J. Stanley Warford
• Coding the Lehmer Pseudo random Number Generator
• from W. H. PAYNE
• The most commonly used version of the Mersenne Twister algorithm
• is based on the Mersenne prime expr { 2**19937-1 }
• TWISTER = 431542479738816264805523551633791983905393504322.....
• GoDuck search engine < TCL version >
• One Liners Programs Pie in the Sky
• One Liners
• One Liners Programs Compendium [L1 ]
• WIKI BOOKS, Programming_Examples pdf
• WIKI BOOKS, Tcl_Programming_Introduction pdf
• Note. I did find a useful online IDE, jdoodle
• Note. I can paste, edit, and run an output using this online IDE.
• How Do I Write Pseudocode? video by Mr. Brown CS
• Refers to rand, RandMT, Mersenne Twister, & random
• Suchenworth RS on Horseracing in Tcl.
• Random Number Generators: Good Ones Are Hard to Find, Keith Willam Miller, pdf online
• Throwing Two Dice GWM and Dice by Keith Vetter.
• int from RLE has dice expression expr {1 + int(rand()*6)} RLE.
• Several Dr. Math emails may reduce some dice issues to simple paths, internet archive.
• Counting Elements in a List from RWT.

Extra Credit on One Line Procedures

• Little L Programming Language
• Let's assign with let
• let
• let2
• Easy Eye Calculator [L2 ]
• Tcl the Misunderstood
• Maximum nummeric value from max
• L-Language pdf L , by Larry McVoy:
• One liners Programs Pie in the Sky
• Counting characters in a string
• Playing with recursion
• recursive functions
• If we had no expr
• expr
• little language
• string is

• Wikipedia search engine < random >
• Wikipedia search engine < dice >
• Wikipedia search engine < Programming Examples >
• Google search engine < vaporware >
• One Liners Programs Pie in the Sky
• One Liners
• One Liners Programs Compendium [L3 ]
• WIKI BOOKS, Programming_Examples pdf
• WIKI BOOKS, Tcl_Programming_Introduction pdf
• google search engine < HgA1c to Average Blood Glucose>

Screenshots Section

figure 1. Slow Series Convergence for Brun Constant

Twin Primes Follow up with Pseudocode Slow Series Convergence for Brun Constant

gold Off the cuff, that double exponential curve fit seems to be tracking fairly well.

figure 1a. Bruns constant in lower primes field

Credit to Wikipedia-(Kiwi128) Bruns constant in lower primes field. The convergence to B2. Each dot represents the effect of an additional pair of twin primes. While the exact value of B2 is unknown, it is thought to be around 1.9 (red line). Calculations have shown it to be greater than 1.83 (blue line)

figure 1c. Bruins constant series

Number theory - 2018-08-08, chat.stackexchange.com

figure 2.

figure 3.

figure 4.

figure 5.

figure 6.

figure 7.

figure 8.

figure 9.

figure 10.

figure 11.

figure 12.

Auxiliary Code Under Test

Hidden Comments Section

# pseudocode
# example to illustrate this process:


# Function to check if a number is prime
function is_prime(n):
    if n < 2:
        return False
    for i from 2 to sqrt(n):
        if n % i == 0:
            return False
    return True

# Function to find twin prime pairs and calculate the gap

function find_twin_primes():
    twin_primes = []
    for i from 2 to MAX_NUMBER:
        if is_prime(i) and is_prime(i + 2):
            twin_primes.append((i, i + 2))
    
    prime_gaps = []
    for pair in twin_primes:
        gap = pair[1] - pair[0]
        prime_gaps.append(gap)
    
    return prime_gaps

# Function to calculate the average of prime gaps

function calculate_average(gaps):
    total = 0
    for gap in gaps:
        total += gap
    average = total / len(gaps)
    return average

# Main program
twin_prime_gaps = find_twin_primes()
average_gap = calculate_average(twin_prime_gaps)
print("Average gap between twin primes: ", average_gap)