Added functions for Ht large z computation

[km-git-acc]

There is a new branch Ht_largez_computation. I have not requested for a merge yet since it may need some more work.

In that branch's utility.py there are several new functions

Ittheta_scaled_by_exp_z_pi_by_8(b,beta,t,theta=0)
Kttheta_scaled_by_exp_z_pi_by_8(z,t,n=5)
Ht_large_scaled_by_exp_z_pi_by_8(z,t)
Ht_large_root_finding_helper(z_as_array,t)
Ht_large_root_finder(complex_guess,t)

Essentially, Ht is being computed using the Ittheta and Kttheta functions derived in Terry's blogpost. I have scaled up all the computations by exp(PIx/8), since exp(-1PI*x/8) is the main decay factor in Ht. By scaling up the integrand itself we can make the computations more stable, and avoid small values.

For example, we saw in one of the output files fluctuations in the T heights when they should keep increasing
t, n+1th zero, zero location
0.2 126 564.9305992829857
0.2 127 561.9850395375217
0.2 128 569.6719475748397

corresponding 2*zeta zero for the middle line is 566.42346
Ht_large_root_finder(566,0.2) gives 565.61166

But there are still some problems. Different starting values still converge at somewhat different locations.
The n parameter and the integration upper limit parameter may have to be tinkered with. We may also have to go for arbitrary precision libraries.

Please check.

[km-git-acc]

Have added another file to this branch called mputility.py where I am trying to do the computations using the mpmath library for arbitrary precision. As expected its much slower than numpy and scipy, but may be required when they can no longer provide the precision required (as seen after the first 100 zeroes).

Have to still add the corresponding Kttheta and Ittheta functions, similar to the ones in utility.py

[sujitnair]

@km-git-acc

I will have a look at it tonight. Is the goal to compute large zeroes for a given t?

Also, can you add docstring to the function with a link to Terry's blog so that we know what you are referring to? Thanks!

[sujitnair]

@km-git-acc

Is my understanding correct that as of now, we are doing the following

1. We are using first_1000_zeta and use these values as an initial condition for fsolve (Newton-Raphson?)
2. Each first_1000_zeta gives us a root for H_0
3. We expect fsolve to find a root for H_t which is the closest to the initial condition

Right?

[km-git-acc]

Added function descriptions.

1. Yeah, we are using 2*zeta zeroes as initial guesses for roots of H_t. fsolve may use any algorithm to find the root (i think currently it is secant method, not the Newton Raphson method).

2. Roots of H_0 are 2*roots of zeta function
   28.26 -> 2 * 14.13 and so on

Yes, fsolve will find the closest H_t root. How well this root is estimated depends on various factors

• how well is Ht calculated (not very good for large z values), but the Ittheta and Kttheta approach is expected to mitigate this
• whats the precision provided by the scipy library (not as much as is needed for large z values, where Ht becomes quite small). Arbitrary precision library like mpmath can help (although it is much slower). Check mputility.py
• Whether there are close roots . This may make fsolve go into long loops and bail out.

Ofcourse fsolve is fundamentally not necessary (but highly useful) if one is only trying to find real roots. One could just keep evaluating Ht at small intervals of real z (intervals should keep getting finer as z increases), and then look for sign changes