# following statements can be pasted into TCL console
        set project 1.0
        proc gaussian_primes {n} { return [/ $n [log $n] ]    }
        puts "gaussian_primes [ gaussian_primes 100   ] " #  answer 21.71472409516259 
        proc legendre_primes2 {n} { return [/ $n [- [log $n] 1.] ]   }
        puts "legendre_primes2 [ legendre_primes2 100   ] " #  answer 27.73794157864211 
        proc modified_legendre_primes3 {n} { return [/ $n [- [log $n] 1.08366] ]   }
        puts "modified_legendre_primes3 [ modified_legendre_primes3 100   ] "  #  answer 28.39690778061494 
        #  answer 25 prime_counting_functionx for 100   is    25         #  answer 25
        # nth prime f(x) =~~ 1.13*log(x)
        proc mod_percent {n} { set aa [/ $n [- [log $n] 1.08366] ] ;return [* [/ $aa $n ] 100. ]  }
        # percentage of primes at given number n from modified_legendre_primes3
        # shows increasing rarity of primes as n increases beyond 1E12
        # Riemann Hypothesis Equivalent, For all x => 2.01,abs {prime_pi(x) − Li(x)} =< sqrt(x) * log(x).
        # prime number theorem,  Li(x)=∼~ prime_pi(x) 

    # scratch development on one liner program
    # preceding from fixed or hard wired formula to general formula
    proc tester1 nn  { [- [log 10000. ] [/ 10000.  1229.   ]]  }
    proc tester2 nn   { [- [log $nn ] [/  [* $nn  1.]  [ llength [ primesLowerThan   $nn ]]    ]]  }
    proc modified_legendre_prime_constant1 nn  { [- [log $nn ] [/ [* $nn  1.] [ llength [ primesLowerThan $nn ]]]]}
    # proc seemed to work better on the local TCL 8.6 set with a return statement?
    proc modified_legendre_prime_constant2 nn  { return [- [log $nn ] [/ [* $nn  1.] [ llength [ primesLowerThan $nn ]]]]}
    # possible  warning for lengthy time calls on primesLowerThan  for high numbers greater than 10K 
    # need to keep isolating spaces in math ops statements
    #Usage for 10K,   modified_legendre_prime_constant 10000   returns 1.073643
    #Usage for 100K,   modified_legendre_prime_constant 100000   returns 1.087571
    #Usage for 1000K,   modified_legendre_prime_constant 1000000   returns 1.076332

            # average gap approximate between primes in near field, 
            # from Gauss in 1792/3 CE. approximate only, not exact
            proc gaussian_prime_density_approx {aa} {[/ 1.  [log $aa]]}
            proc gaussian_prime_average_gap_approx {aa} { [log $aa]}
            proc pg {aa} { [log $aa]}
            # check from  prime number series 3,5,7,  near 5
            #  [- 5 3] =2  ,  [- 7 5] =2 ,   pg 5 > 1.6
            # check from  prime number series  23, 29, 31, 37,  near 30
            # [- 29 23]=6, [- 31 29]=2,.[- 37 31]= 6
            #   pg 30 = 3.401, (6+2+6)/3= 4.666  
            # list_twin_primes proc  under test, list_twin_primes
            # and isprime procs are recursion limited, using TCLLIB isprime here
            proc list_twin_primes { aa bb cc} { for {set i $aa} {$i<=$bb} {incr i 1} { if {[isprime $i] && [isprime [+ $i $cc ] ] } {  lappend  boo  $i  [+ $i $cc ]   } } ; return $boo}
            # aa is lower limit or start number, 
            # bb is upper limit or end number.
            # cc is separator number, usually even 2
            # contains redundant commands for testing
            puts "[list_twin_primes 3 25 2 ]"
            puts "[list_twin_primes 3 25 4 ]"
            puts "[list_twin_primes 3 25 6 ]"
            puts "[list_twin_primes 3 25 10 ]"
            # The original Dickson conjecture has separator even numbers 2,4,6 ... ?
            # list_twin_primes 0 25 2 returns 3 5 5 7 11 13 17 19 
            # The sets <13 15> and <15 17> are separated by a even 2,
            # but left out of answer.
            # Note the 15 is not a prime number and has factors <3 5>.
            # The set <13 17> has two primes, but separated by an even 4.
            # reference On-Line Encyclopedia of Integer Sequences website
            # OEIS A077800 discussed that the twin prime sets <p,p+2> are
            # (3, 5), (5, 7), (11, 13), (17, 19), 
            # (29, 31), (41, 43), (59, 61), (71, 73),
            # (101, 103), (107, 109), (137, 139)...
            # OEIS A275021 has  samples of <p,p+4> and omits pairs of <p,p+2>
            # 79, 83, 127, 131, 163, 167, 379, 383, 397, 401, 439, 443,...
            # list_twin_primes 75 135 4 returns 79 83 103 107 127 131
            # OEIS A023201 has some samples of <p,p+6> 
            # 5, 7, 11, 13, 17, 23, 31, 37, 
            # 41, 47, 53, 61, 67, 73, 83, 97, 101
            # list_twin_primes 3 25 6
            # returns 5 11 7 13 11 17 13 19 17 23 23 29
            # list_twin_primes 3 25 10
            # returns 3 13 7 17 13 23 19 29

  listPrimePairs 
  listPrimeProgressions

    # pseudocode
    set ncat   [ llength [primesLowerThan 20]]
    # 8
    set dd [ primesLowerThan  20   ]
    # 2 3 5 7 11 13 17 19  ;# oeis 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 
    set dd  { 2 3 5 7 11 13 17 19 }
    proc list_twin_primes { aa bb cc} { for {set i $aa} {$i<=$bb} {incr i 1} { if {[isprime $i] && [isprime [+ $i $cc ] ] } {  lappend  boo  $i  [+ $i $cc ]   } } ; return $boo}
    # aa is lower limit or start number,
    # bb is upper limit or end number.
    # cc is separator number, usually even 2
    # under test, contains redundant commands for testing
    proc pdf { aa bb cc} { foreach {a b} [ primesLowerThan  20   ] { lappend  booo    [-   $b  $a ]  } ; return $booo }
    pdf  0 20 2
    # 1 2 2 2
    proc pdf2 { nn} { foreach {a b} [ primesLowerThan  $nn   ] { lappend  boo    [-   $b  $a ]  } ; return $boo }
    pdf2  20
    # subtracting alternate pairs?   <2 3>  <5 7>  <11 13> <17 19> 
    proc pdf3 { nn} { foreach {a b} [ primesLowerThan  $nn   ] { lappend  boo    [-   $b  $a ]  } ; return $boo }
    pdf2 20
    # 1 2 2 2
    # messing up here, OEIS A001223  has Prime gaps: differences between consecutive primes.
    # 1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4,
    set lister {90.5 47 58 29 22 32 55 5 55 73.5}
    set i 1
    [ lindex  $a $i   ] ;# 47
    [ lindex  $a   [+ $i  1   ] ] ;# 58 
    [-   [ lindex  $a   [+ $i  1   ] ]   [ lindex  $a $i   ] ] ;# 11
    # set r  [ lister[i + 1] - lister[i] for i in range(len(lister)-1)] 

        # pretty print from autoindent and ased editor
        # Gauss approximate number of primes calculator
        # written on Windows XP on eTCL
        # working under TCL version 8.5.6 and eTCL 1.0.1
        # gold on TCL WIKI, 15may2016
        # comment follows from gold, 12Dec2018
        # pretty print from autoindent and ased editor
        # Gauss Approximate Number of Primes Calculator V2
        # written on Windows XP on TCL
        # working under TCL version 8.6
        # Revamping older program from 2016.
        package require Tk
        package require math::numtheory
        #namespace path {math::numtheory}
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        frame .frame -relief flat -bg aquamarine4
        pack .frame -side top -fill y -anchor center
        set names {{} {interval number L1  :} }
        lappend names {end number L2  :}
        lappend names {optional, if one & L2 < 190,  invoke exact solution (? long!!): }
        lappend names {answers: gauss function ~number_primes for N1 :}
        lappend names {legendre function ~number_primes for N1 :}
        lappend names {gauss approx number of primes from zero: }
        lappend names {gauss approx number of primes from zero to interval start: }
        lappend names {gauss number of primes over interval:} 
        foreach i {1 2 3 4 5 6 7 8} {
            label .frame.label$i -text [lindex $names $i] -anchor e
            entry .frame.entry$i -width 35 -textvariable side$i
            grid .frame.label$i .frame.entry$i -sticky ew -pady 2 -padx 1 }
        proc about {} {
            set msg "Calculator for Gauss Approximate Number of Primes V2
            from TCL ,
            # gold on  TCL Club, 12Dec2018 "
            tk_messageBox -title "About" -message $msg } 
            # ref. TCLLIB::math::numtheory::prime_counting_functionx 
            # ref. alternate TCLLIB::math::numtheory::isprime 
        proc self_help {} {
            set msg "  Gauss Approximate Number of Primes V2
            from TCL Club ,
            # self help listing
            # problem,  Gauss Approximate Number of Primes V2
            # 3 givens follow.
            1) interval number L1:
            2) end number L2:
            3) optional, if one & L2 < 190,  invoke exact solution (? long!!):
            # Recommended procedure is push testcase
            # and fill frame,
            # change first three entries etc, push solve,
            # and then push report.
            # Report allows copy and paste
            # from console to conventional texteditor.
            # For testcases, testcase number is internal
            # to the calculator and will not be printed
            # until the report button is pushed
            # for the current result numbers.
            # >>> copyright notice <<<
            # This posting, screenshots, and TCL source code is
            # copyrighted under the TCL/TK license terms.
            # Editorial rights and disclaimers
            # retained under the TCL/TK license terms
            # and will be defended as necessary in court.
            Conventional text editor formulas
            or  formulas grabbed from internet
            screens can be pasted into green console.
            # gold on  TCL Club, 12Dec2018 "
            tk_messageBox -title "Self_Help" -message $msg }
             proc prime_counting_function { start  end } {
             set start [int $start ]
             set end [int $end ]
             set counter 0
             if { $start > 1  } { set counter  $start  } 
             set end  $end 
             set prime_counting_function 0
             while { $counter < $end  } {
             incr counter 
             incr  prime_counting_function  [isprime $counter ] 
             }
             return $prime_counting_function }  
       proc calculate {     } {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8 
            global switch_factor big_giant_list legendre_function
            global testcase_number 
            incr testcase_number 
            set side1 [* $side1 1. ]
            set side2 [* $side2 1. ]
            set side3 [* $side3 1. ]
            set side4 [* $side4 1. ]
            set side5 [* $side5 1. ]
            set side6 [* $side6 1. ]
            set side7 [* $side7 1. ]
            set side8 [* $side8 1. ]
            set L1 $side1  
            set L2 $side2  
            set N1 $side2 
            set switch_factor $side3 
            set approx_number_primes [/ $N1   [log $N1 ] ] 
            set legendre_function  [/ $N1   [- [log $N1 ] 1.08366 ] ] 
            # conditions, all numbers real and positive. 
            # conditions L1 =! 1 and L2 > L1, otherwise division by zero and undefined Q's.
            # if { $L1 == 1.0 } { set $L1 0.0 } 
            set approx_number_primes_interval_start [/ $L1   [log $L1 ] ]
            set approx_number_primes_over_interval [- [/ $L2   [log $L2 ] ] [/ $L1   [log $L1 ] ] ]
            set side4 $approx_number_primes
            set side5 $legendre_function
            set side6 $approx_number_primes 
            set side7 $approx_number_primes_interval_start
            set side8 $approx_number_primes_over_interval
            if { $switch_factor > 0 && $L2 < 200 } { exact_solution } 
                    }
            proc listprimes { aa bb} {lappend booboo 2.0; for {set i 1} {$i<=$bb} {incr i 2} { if {[isprime $i] } {lappend booboo [expr 1.*$i]   } };return $booboo}
            #returns list of prime numbers  from aa to bb, usage [listprimes 0 25],
            # answer is 2.0 3.0 5.0 7.0 11.0 13.0 17.0 19.0 23.0, 
            # list returned as real numbers, not counting 1.0 unity
               proc exact_solution {} {
            global side1 side2 side3 side4 side5
            global side6 side7 side8 big_giant_list prime_counting 
            set big_giant_list  [ listprimes $side1 $side2 ]           
            set side8 [ llength $big_giant_list ] 
             }
        proc fillup {aa bb cc dd ee ff gg hh} {
            .frame.entry1 insert 0 "$aa"
            .frame.entry2 insert 0 "$bb"
            .frame.entry3 insert 0 "$cc"
            .frame.entry4 insert 0 "$dd"
            .frame.entry5 insert 0 "$ee"
            .frame.entry6 insert 0 "$ff" 
            .frame.entry7 insert 0 "$gg"
            .frame.entry8 insert 0 "$hh" 
             }
        proc clearx {} {
            foreach i {1 2 3 4 5 6 7 8 } {
                .frame.entry$i delete 0 end } }
        proc reportx {} {
            global side1 side2 side3 side4 side5
            global side6 side7 side8
            global switch_factor big_giant_list legendre_function
            global testcase_number
            console eval {.console config -bg palegreen}
            console eval {.console config -font {fixed 20 bold}}
            console eval {wm geometry . 40x20}
            console eval {wm title . " Gauss Approximate Number of Primes V2 Report, screen grab and paste from console 2 to texteditor"}
            console eval {. configure -background orange -highlightcolor brown -relief raised -border 30}
            console show;
            puts "%|table $testcase_number|printed in| tcl wiki format|% "
            puts "&| quantity| value| comment, if any|& "
            puts "&| testcase number:|$testcase_number | |&"
            puts "&| $side1 :|interval L1   |   |&"
            puts "&| $side2 :|end number L2  | |& "  
            puts "&| $side3 :|optional,if one,  invoke exact solution (? long) | |& "
            puts "&| $side4 :|answers: gauss function ~number_primes| |&"
            puts "&| $side5 :|legendre function ~number_primes| |&"
            puts "&| $side6 :|gauss approx_number_primes  |  |&"
            puts "&| $side7 :|gauss approx_number_primes_interval_start |  |&"
            puts "&| $side8 :|gauss number_primes_over_interval |  |&" 
            puts "&| $legendre_function :|legendre_function number_primes_N1|  |&"
            if {$switch_factor > 0.0} { puts "&| [prime_counting_function $side1 $side2  ] :|prime_counting_function over interval|  |&" }
            if {$switch_factor > 0.0 && $side2 < 190.} {puts "&| $big_giant_list :|list number_primes_over_interval |  |&" }
            }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 0.0 1E1 1.0 4.3  8.20  4.3 0.00 4.30}
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 0.0 5.0 1.0 3.1  9.50  3.1 0.00 3.10 }
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 1E3 1E6 1.0 7E5  7E5 72382.0 0.0 72382.0 }
        ::ttk::button .clearallx -text clear -command {clearx }
        ::ttk::button .about -text about -command {about}
        ::ttk::button .self_help -text self_help -command { self_help }
        ::ttk::button .cons -text report -command { reportx }
        ::ttk::button .exit -text exit -command {exit}
        pack .calculator  -in .buttons -side top -padx 10 -pady 5
        pack  .clearallx .cons .self_help .about .exit .test4 .test3 .test2   -side bottom -in .buttons
        grid .frame .buttons -sticky ns -pady {0 10}
               . configure -background aquamarine4 -highlightcolor brown -relief raised -border 30
        wm title . "Gauss Approximate Number of Primes Calculator V2"

  puts " %| testcase $testcase_number | value| units |comment |%"
  puts " &| volume| $volume| cubic meters |based on length $side1 and width $side2   |&"  

                  # autoindent from ased editor
                  # console program for graph numbers 
                  # written on Windows XP on eTCL
                  # working under TCL version 8.5.6 and eTCL 1.0.1
                  # TCL WIKI , 12dec2016
             console show
             package require math::numtheory
             #namespace path {math::numtheory}
             namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
             set tcl_precision 17
             proc factors {} {
             set counter 0
             set prime_counting_function 0
             while {$counter < 500} {
             puts " [* $counter 1.] ,  [/ [* $counter 1.] [log [* $counter 1.]] ],  [isprime $counter ],  $prime_counting_function   "
             incr counter 
             incr  prime_counting_function  [isprime $counter ] 
             }
             return }
             factors

 2.0 ,  2.8853900817779268,  1,  1   
 3.0 ,  2.7307176798805122,  1,  2   
 4.0 ,  2.8853900817779268,  0,  2   
 5.0 ,  3.1066746727980594,  1,  3   
 6.0 ,  3.3486637593074837,  0,  3   
 7.0 ,  3.5972883965882549,  1,  4   
 8.0 ,  3.8471867757039027,  0,  4   
 9.0 ,  4.0960765198207678,  0,  4   
 10.0 ,  4.3429448190325175,  0,  4   

             # under test, biasing approx. from interval to save computer time
       proc prime_counting_function { start  end } {
             set counter 0
             if { $start > 1  } { set counter [int $start ]  } 
             set end [int $end ] 
             set prime_counting_function 0
             while { $counter < $end  } {
             incr counter 
             incr  prime_counting_function  [isprime $counter ] 
             }
             return $prime_counting_function }  
        proc biased_count { N1    } {
             set N1 [int $N1 ]
             set bias1 [* 1. [ prime_counting_function [int  [* $N1 .99] ] $N1 ]]
             set bias2  [* 1. [ prime_counting_function $N1 [int [* $N1 1.01]]   ]]
             puts " $bias1 "
             puts " $bias2 "
             set bias 1.
             set approx_number_primes 1.
             set bias [expr  $bias2/ double($bias1)  ] 
             puts " $bias $bias2   $bias1 "
             set approx_number_primes [* [/ $N1   [log $N1 ] ] $bias ]
             return $approx_number_primes
             }

        # pretty print from autoindent and ased editor
        # testing devil's notch
        # prime number function from TCLLIB  
        # written on Windows XP
        # working under TCL version 8.6.6
        # gold on TCL WIKI , 20dec2017
        package require Tk
        package require math::numtheory
        package require math::constants
        #package require math::bigfloat
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory  math::constants }
       console show
       # corrected legendre_function  
       proc leg {N1 N2 } {
       set legendre_function  [/ $N1   [- [ ::tcl::mathfunc::log $N1 ] 1.08366 ] ] 
       set legendre_functionx  [/ $N2   [- [ ::tcl::mathfunc::log $N2 ] 1.08366 ] ] 
       return [- $legendre_functionx $legendre_function  ]
       }
       set numberx [ ::math::numtheory::prime_counting_functionx   450  550  ]
       puts "prime counting function  $numberx  corrected legendre [ leg 450. 550. ] "
       set numberx [ ::math::numtheory::prime_counting_functionx   550  650  ]
       puts "prime counting function  $numberx  corrected legendre [ leg 550. 650. ] "
       set numberx [ ::math::numtheory::prime_counting_functionx   650  750  ]
       puts "prime counting function  $numberx  corrected legendre [ leg 650. 750. ] "
       # padded statements into <local> ::math::numtheory::prime_counting_functionx   
       # for list of primes in interval 
       #if {[::math::numtheory::isprime $counter ] } {  lappend lister $counter }
       #      }
       # puts $lister

        # pretty print from autoindent and ased editor
        # console program for prime_counting_function
        # keywords prime counting function
        # written on Windows XP on  TCL
        # working under TCL version 8.6
        # gold on TCL WIKI, 4feb2018
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        console show
        # adapted from sum_primes_to by dkf
        # from  Comparing Tcl and Python on TCL WIKI
        # advantage: no dependency on expr or isprime.
        # large numbers > 10E3 can take a long time.
        proc prime_counting_function {n {i 1}} {
            set total 0
            incr n 0
            for {set q [+ $i $i ]} {$q < $n} {incr q} {
                if {![info exists d($q)]} {
                    incr total
                    lappend d([* $q $q ]) $q
                } else {
                    foreach p $d($q) {
                        lappend d([+ $p $q ]) $p
                    }
                    unset -nocomplain d($q)
                }
            }
            return $total
        }
        puts " prime_counting_function for 100 , answer [prime_counting_function 100]
        puts " time note   [ time {prime_counting_function 100} 100 ] "
        #  prime_counting_function for 100 , answer 25
        #  time note   273.35 microseconds per iteration 

        # pretty print from autoindent and ased editor
        # written on Windows XP on TCL
        # working under TCL version 8.6
        # gold on TCL WIKI , 2feb2018
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory}
        set tclprecision 17
        console show
        # based on all_primes proc in Sample Math Programs on TCL WIKI
        proc prime_counting_functiont {max} {
            # from  rwt? on TCL WIKI
            set counter 1
            set primes [list 2]
            for {set test 3} {$test <= $max} {incr test 2} {
                set maxTest [int [sqrt $test ]]
                foreach prime $primes {
                    if {$prime  > $maxTest} {
                        # puts $test list omitted for time save
                        lappend primes $test
                        incr counter
                        break
                    }
                    if {![% $test $prime ]} {
                        break
                    }
                }
            }
            return $counter
        }
        puts " prime_counting_functiont answer [ prime_counting_functiont 100]"
        puts " prime_counting_functiont time note   [ time { prime_counting_functiont 100 } 300 ]  "
        # prime_counting_functiont answer 25
        # prime_counting_functiont time note   165.896 microseconds per iteration 

        # following statements can be pasted into TCL console
        set project 1.0
        set P_2 expr { 1./(2*2)+1./(3*3)+1./(5*5)} #0.40111 
        set P_2 expr { 1./(2*2)+1./(3*3)+1./(5*5)+1./(7*7)+1./(11*11)+1./(13*13)} # 0.43570 

        # pretty print from autoindent and ased editor
        # console program for prime_zeta_function
        # keywords sum  squares prime zeta function Sieve Eratosthenes
        # written on Windows XP on  TCL
        # working under TCL version 8.6
        # gold on TCL WIKI, 4feb2018
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        console show
        # adapted from sum_primes_to by dkf
        # from  Comparing Tcl and Python on TCL WIKI
        # advantage: no dependency on expr or isprime.
        # large numbers n  > 10E3 can take a long time.
        # P(order 1) is divergent, P(n),n>1 should be convergent.
        proc prime_zeta_function {bb n} {
            # tally sequence of prime numbers via the Sieve of Eratosthenes.
            # n is highest integer to test
            # i subintegers to test as factors
            # D()  # map composite integers to primes witnessing their compositeness
            # q = integer to test for primality (usually starts at 2 )
            # total here, sum of reciprocals of prime squares or powers
            # bb is square or power for reciprocal denominator
            # prime zeta function P(1) is divergent at inf, higher P() converge
            # if q and p are odd, q+2*p will always be odd. 
            # all even numbers n() are not prime, except 2.
            set total 0
            incr n 0
            set i 1
            for {set q [+ $i $i ]} {$q < $n} {incr q} {
                if {![info exists d($q)]} {
                    # add 1/n**bb to tatal if n prime
                    set total [+ $total [/ 1. [* $q $q ] ]]
                    # add to current map 
                    lappend d([* $q $q ]) $q
                } else {
                    # move each witness to its next multiple
                    foreach p $d($q) {
                        lappend d([+ $p $q ]) $p
                    }
                    unset -nocomplain d($q)
                    # dump map
                }
            }
            return $total
        }
        puts " prime_zeta_function for {2 6} , answer [prime_zeta_function 2 6] "
        puts " time note   [ time {prime_zeta_function 2 5} 100 ] "
        puts " prime_zeta_function for {2 10000} , answer [prime_zeta_function 2 10000 ] "
        puts " time note   [ time {prime_zeta_function 2 10000} 100 ] "       
        # prime_zeta_function for {2 6} , answer 0.40111111111111108 
        # time note   11.390000000000001 microseconds per iteration 
        # prime_zeta_function for {2 10000} , answer 0.45223760433995064 
        # time note   71381.509999999995 microseconds per iteration 

         proc report {n} {
         set count 1
         set lister {}
         set lister {0. 0.452247 0.174763 0.0769931 0.035755 0.0170701 0.00828383 0.00406141 0.00200447 0.000993604 }
         puts "%|table testcases number||||printed in| tcl wiki format|% "
         puts "%|testcase |P(order)|TCL n value |TCL proc prime_zeta_function |P() standard at inf | comment, if any|% "            
         foreach item { 2 3 4 5 6 7 8 } {
         puts "&| testcase $count | $item |1E6  |[ prime_zeta_function $item 1000000 ] | [lindex $lister $count]||&"
         incr count 1
         }}
         report 2