ABSTRACT (original article): Study of the level curve for the real part of
η(s)=0
with
η(s)=
-s/2
π
Γ(s/2)
′
ζ
(s)
gives a new classification of the zeros of
ζ(s)
and of
′
ζ
(s)
. We conjecture that for type 2 zeros,
Liminf(
′
β
-1/2)log
′
γ
=0
if and only if
Liminf(
+
γ
-
-
γ
)log
′
γ
=0
, and reduce the conjecture to a lower bound on the curvature of the level curve. We compute and classify
6
10
zeros of
′
ζ
(s)
near
T=
10
10
. The Riemann Hypothesis is assumed throughout. An appendix develops the analogous classification for characteristic polynomials of unitary matrices. CITATION (original article): Jeffrey Stopple (2025), Level curves for Zhang’s Eta Function, arXiv:2503.07696. https://doi.org/10.48550/arXiv.2503.07696

Zeros of
′
ζ
(s)
: Argument Principle Search

Here we create a table of zeros of the derivative of the Riemann zeta function,
′
ζ
(s)
, in a rectangular box high up in the critical strip. (The Riemann Hypothesis, which we are assuming, gives the real part > 1/2, and it is known the real part is <3.). The overall plan is to divide the large (portrait oriented) rectangle into many small (landscape oriented) rectangles, and evaluate the derivative at a grid of points in each. The Argument Principle tells us there is a zero in a rectangle if the the change in argument going around the perimeter is (a multiple of) 2Pi.
In[]:=
bigstep=10;SetSharedVariable[monitor];
monitor=0;​​zeros=MonitorParallelTable​​(**)​​ZP[s_?NumericQ]:=ZP[s]=N-20019923090075Zeta[s]-34359738368Zeta
1
128000
+s+17045651456Zeta
1
64000
+s-2796552192Zeta
1
32000
+s+193511424Zeta
1
16000
+s-6047232Zeta
1
8000
+s+85344Zeta
1
4000
+s-508Zeta
1
2000
+s+Zeta
1
1000
+s15625953;​​Attributes[ZP]={Listable};​​ZetaPrime[s_?NumericQ]:=-20019923090075Zeta[s]-34359738368Zeta
1
128000
+s+17045651456Zeta
1
64000
+s-2796552192Zeta
1
32000
+s+193511424Zeta
1
16000
+s-6047232Zeta
1
8000
+s+85344Zeta
1
4000
+s-508Zeta
1
2000
+s+Zeta
1
1000
+s15625953;​​ArgChange[list_]:=Plus@@Arg[Ratios[list]];​​flag=1;​​step=120;​​Label[recompute1];​​bottom=ArgChange[ZP[Table[jj+I*bigjj,{jj,1/2,3,step}]]];​​right=ArgChange[ZP[Table[3+I*jj,{jj,bigjj,bigjj+bigstep,2*step}]]];​​top=ArgChange[ZP[Table[jj+I*(bigjj+bigstep),{jj,3,1/2,-step}]]];​​left=ArgChange[ZP[Table[1/2+I*jj,{jj,bigjj+bigstep,bigjj,-step/4}]]];​​truecount=Round[(bottom+right+top+left)/(2Pi)];​​re={1/2,3};​​im={bigjj,bigjj+bigstep};​​Label[recompute2];​​(*Thevariable'boxtable'storestheargumentofthederivativeatthecornersofallthesquaresfillingthesmallrectangle*)boxtable=Flatten[Table[{ii+Ijj,ii+step/2+Ijj,ii+step+Ijj,ii+step+I(jj+step/2),ii+step+I(jj+step),ii+step/2+I(jj+step),ii+I(jj+step),ii+I(jj+step/2),ii+Ijj},Evaluate@{ii,Sequence@@(re-{0,step}),step},Evaluate@{jj,Sequence@@(im-{0,step}),step}],1];​​(*Thevariable'goodboxtable'storesallthesquareswhichcontainazeroofthederivative.*)​​goodboxtable=Select[boxtable,Round[(Plus@@Map[Arg,Ratios[ZP[#]]])/(2Pi)]>0&];​​goodboxtable=Transpose[{goodboxtable[[All,1]],goodboxtable[[All,5]]}];​​goodboxtable=Map[(#+{-step/3-Istep/3,step/3+Istep/3})&,goodboxtable];​​If[truecount!=Length[goodboxtable]&&flag<3,step=step/2;flag++;Goto[recompute1]];​​(*LocatingzerosusingFindRoot*)​​localzeros=Map[Quiet[Check[s/.FindRoot[ZetaPrime[s],{s,Mean[#],Sequence@@#},WorkingPrecision->30,AccuracyGoal->5],{}]]&,goodboxtable]//Flatten;​​If[truecount!=Length[localzeros]&&flag==3,Print["Aborting... bigjj= ",bigjj," errorcount= ",truecount-Length[localzeros]]];​​If[truecount!=Length[localzeros]&&flag<3,Print["bigjj= ",bigjj," flag=",flag," errorcount= ",truecount-Length[localzeros]];flag++;step=step/2;Goto[recompute2]];​​monitor=monitor+Length[localzeros];​​Clear[ZP];​​localzeros,​​{bigjj,10^10+27000*bigstep,10^10+30699*bigstep,bigstep},Method->"FinestGrained",ProgressReporting->True,monitor//Flatten;
In[]:=
Length[zeros]
Out[]=
120663
In[]:=
ZP[s0_]:=N-
1000
21
315Zeta[s0]-512Zeta
1
8000
+s0+224Zeta
1
4000
+s0-28Zeta
1
2000
+s0+Zeta
1
1000
+s0
The derivative of the zeta function is computed via Richardson extrapolation, just as does the Mathematica package NumericalCalculus. There are two different implementations. The function ZP[s_] is wrapped with N[ ], and saves its values. This is used to compute the arguments at the corners of boxes, and save time because each point evaluation is actually the corner of four different boxes in the grid. The function ZetaPrime[s_] is not wrapped with N[ ] and does not save values; it is what is given to FindRoot.
There is some basic error checking if the number of zeros found does not match the number expected via the Argument Principle - we decrease the step size of the boxes and recompute. The variable flag is used to abort the calculation if we’ve already recomputed three times.
After computing the table, we do a quick check that we seem to have computes actual zeros of the derivative, and then sort the file so the imaginary parts are in increasing order.
In[]:=
Max[Abs[ParallelMap[ZP,zeros]]]
Out[]=
5.10193×
-6
10
In[]:=
Sort[zeros,(Im[#1]<Im[#2])&]>>zetaprimezeros.9.txt

Zeros of
′
ζ
(s)
: Hardy Z Sign Changes

We create a table of the imaginary part of the zeros of the Riemann Zeta function. (We are assuming the Riemann Hypothesis, so the real parts are all one half.). The zeros should lie on the left side of the large (portrait oriented) rectangle of the previous computation. (The attached notebook is actually a test version that only considers a small portion of the critical line). The calculation is a loop in which this left side is divided up into segments of length bigstep which is equal 10. Each segment sits inside a (landscape oriented) rectangle from real part=1- to real part =+2. We compute the change in the argument of Zeta[s] around this rectangle to determine, via the Argument Principle, how many zeros of Zeta[s] it contains, and store this as truecount. We divide the segment of the critical line inside this rectangle into intervals of size step equal 1/20, and store this as the table boxtable. (These are intervals not boxes, but the nomenclature is carried over from the previous notebook.). The table goodboxtable contains those intervals in which the Hardy Z function RiemannSiegelZ[t] shows a sign change (and thus a corresponding zero of Zeta[s] on the critical line.). Wolfram’s FindRoot applied to the function RiemannSiegelZ[t] locates the zeros. We check that the number of zeros truecount predicted by the Argument Principle matches the length of the table localzeros actually found. If not, we decrease the step size and recompute. If the variable flag shows we’ve already recomputed 3 times, we abort the calculation.
In[]:=
bigstep=10;SetSharedVariable[monitor];
In[]:=
monitor=0;​​zeros=Monitor[ParallelTable[​​(**)​​HardyZ[t_?NumericQ]:=HardyZ[t]=N[RiemannSiegelZ[t]];​​Attributes[HardyZ]={Listable};​​ArgChange[list_]:=Plus@@Arg[Ratios[list]];​​flag=1;​​step=1/20;​​Label[recompute1];​​bottom=ArgChange[Map[N[Zeta[#]]&,Table[jj+I*bigjj,{jj,-1,2,step}]]];​​right=ArgChange[Map[N[Zeta[#]]&,Table[2+I*jj,{jj,bigjj,bigjj+bigstep,5*step}]]];​​top=ArgChange[Map[N[Zeta[#]]&,Table[jj+I*(bigjj+bigstep),{jj,2,-1,-step}]]];​​left=ArgChange[Map[N[Zeta[#]]&,Table[-1+I*jj,{jj,bigjj+bigstep,bigjj,-step/5}]]];​​truecount=Round[(bottom+right+top+left)/(2Pi)];​​im={bigjj,bigjj+bigstep};​​Label[recompute2];​​boxtable=Table[{jj,jj+step},Evaluate@{jj,Sequence@@(im-{0,step}),step}];​​goodboxtable=Select[boxtable,(Sign[HardyZ[#[[1]]]]!=Sign[HardyZ[#[[2]]]])&];​​If[truecount!=Length[goodboxtable]&&flag<3,step=step/2;flag++;Goto[recompute1]];​​localzeros=Map[Check[t/.FindRoot[RiemannSiegelZ[t],{t,Sequence@@#},WorkingPrecision->30,AccuracyGoal->5,Method->"Brent"],t->{}]&,goodboxtable]//Flatten;​​If[truecount!=Length[localzeros]&&flag==3,Print["Aborting... bigjj= ",bigjj," errorcount= ",truecount-Length[localzeros]]];​​If[truecount!=Length[localzeros]&&flag<3,​​Print["bigjj= ",bigjj," flag=",flag," errorcount= ",truecount-Length[localzeros]];flag++;step=step/2;Goto[recompute2]];​​monitor=monitor+Length[localzeros];​​Clear[HardyZ];​​localzeros,​​{bigjj,10^10,10^10+7*bigstep,bigstep},Method->"FinestGrained",ProgressReporting->True],monitor]//Flatten;
In[]:=
Length[zeros]
Out[]=
270
After computing the table, we do a quick check that we seem to have computes actual zeros of RiemannSiegelZ[t]. I neglected to sort the file so the zeros are in increasing order - because of the parallel computation this is not a given.
In[]:=
Max[Abs[ParallelMap[RiemannSiegelZ,zeros]]]
Out[]=
1.7895105383×
-6
10

Linking Zeros of
′
ζ
(s)
to Zeros of
′
ζ
(s)

Here we input a table of zeros of the derivative of Zeta[s] (output from the first section “Zeros of
′
ζ
(s)
: Argument Principle Search”) stored as rhoprime, and a table of the imaginary parts of the zeros of Zeta[s] (output from the second section “Zeros of
′
ζ
(s)
: Hardy Z Sign Changes”) stored as gamma. We know the level curves where the real part of Zhang’s Eta function
-s/2
π
Γ(s/2)
′
ζ
(s)
is equal zero, generically connect zeros of the Riemann zeta function to zeros of its derivative. This section determines which connect to which for the given data. Specifically, it creates a table rhoprimetypes in which entry k is a table of the indices of all zeros of zeta which connect to the k-th zero of the derivative. For example, if the 10th and 11th zero of zeta connect to the 5th zero of the derivative, then entry 5 of rhoprimetypes is {10,11}. If only the 12th zero of zeta connects to the 6th zero of the derivative, then entry 6 of rhoprimetypes is {12}. If no zeros of zeta connect to the 7th zero of the derivative, then entry 7 is {}.
As before, the derivative is computed via Richardson extrapolation, and there are two implementations: ZP[s], which stores its values and returns a numeric value, and ZetaPrime[s], which does not store values and returns an expression of Zeta. The function ArgGamma[s_] uses Stirling’s Formula to return the argument of the Gamma function. The function FakeEta[s_] has the same argument as Zhang’s Eta function above, but avoids the numerical complications caused by the exponential decay of the absolute value of the Gamma function high in the critical strip.
For each zero of Zeta[s] we define a small square box of side delta equal 1/30, with the zero in the middle of the left side. The basic idea is to use the Intermediate Value Theorem to determine which side of the box the contour exits, and then move the box (up, down, right, or potentially even left) to again capture the contour. The variable upshift, downshift, rightshift and leftshift will do this as needed.
The While loop does the actual moving of the boxes. The table signs tracks the sign of the real part. The variable contourstart tells us which side the contour entered the box. Four If statements depending on where we enter the box use the signs to move the box right, left, down or up. Some error checking for nonsensical answers will redo the calculation with half the value of ‘delta’.
The While loop exits when there is a zero of the derivative inside the box. The variable ‘zetaprimezerosinbox’ collects all elements from rhoprime inside the box - if there’s more than one we redo the computation with half the value of delta.
If there’s exactly one we append append the index of the zero of zeta to the appropriate sub-table in rhoprimetypes.
If there are none, we’ve located a zero of the derivative that was missed by Zeta.Prime.Zeros.X.nb. We save it and the index of the zero we started from.
On exiting the loop over zeros of Zeta, we do some cleanup. For the zeros of the derivative newly discovered (missed by section “Zeros of
′
ζ
(s)
: Argument Principle Search”), we collect the indices of the zeros of Zeta[s] which connect to them via the level curves, and add this data to the file rhoprimetypes. The newly discover zeros are saved as well for future reference.
We see two examples where the process of shifting the boxes produced a nonsensical result. The contours were examined in Mathematica (not in this section); the data was then fixed by hand.
In[]:=
rhoprime=<<zetaprimezeros.0.txt;
In[]:=
gamma=<<zetazeros.0.txt;
In[]:=
SetSharedVariable[rhoprimetypes,extrarhoprime,extratypes,monitor]
rhoprimetypes=Table[{},{jj,1,Length[rhoprime]}];​​extrarhoprime={};​​extratypes={};​​monitor=0;
MonitorParallelDo​​ZetaPrime[s_]:=-20019923090075Zeta[s]-34359738368Zeta
1
128000
+s+17045651456Zeta
1
64000
+s-2796552192Zeta
1
32000
+s+193511424Zeta
1
16000
+s-6047232Zeta
1
8000
+s+85344Zeta
1
4000
+s-508Zeta
1
2000
+s+Zeta
1
1000
+s15625953;​​ArgGamma[s_]:=Im[s]Log[Abs[s]]+(Re[s]-1/2)Arg[s]-Im[s]-Im[s](12Abs[s]^2);​​ZP[s_]:=ZP[s]=N-20019923090075Zeta[s]-34359738368Zeta
1
128000
+s+17045651456Zeta
1
64000
+s-2796552192Zeta
1
32000
+s+193511424Zeta
1
16000
+s-6047232Zeta
1
8000
+s+85344Zeta
1
4000
+s-508Zeta
1
2000
+s+Zeta
1
1000
+s15625953;​​FakeEta[s_]:=Exp[I*(-Im[s]Log[Pi]/2+ArgGamma[s/2])]ZP[s];​​(*Initializeboxsizedelta*)​​delta=130;​​Label[redojjevaluation];​​upshift={delta*I,delta*I,delta*I,delta*I};​​downshift={-delta*I,-delta*I,-delta*I,-delta*I};​​rightshift={delta,delta,delta,delta};​​leftshift={-delta,-delta,-delta,-delta};​​(*Initializecontourboxnearzetaprimezero*)​​rho=12+I*gamma[[jj]];​​parity=Sign[Im[FakeEta[rho]]];​​box={rho+delta/2*I,rho-delta/2*I,rho+delta-delta/2*I,rho+delta+delta/2*I};​​contourstart=left;​​flag=0;​​w=Map[ZP,box];​​(*ComputeZPatfourcorners*)​​countzetapzerosinbox=Round[(Arg[w[[2]]/w[[1]]]+Arg[w[[3]]/w[[2]]]+Arg[w[[4]]/w[[3]]]+Arg[w[[1]]/w[[4]]])/(2Pi)];​​Whilecountzetapzerosinbox<1,​​If[Re[box[[1]]]<1/2||Re[box[[1]]]>3,flag++;If[flag>2,Print["box outside strip error ",jj]];delta=delta/2;Goto[redojjevaluation]];​​(*Computenewbox*)​​signs=Map[Sign[Re[FakeEta[#]]]&,box];​​Ifcontourstartleft,
Set[
]
;​​Ifcontourstartbottom,
Set[
]
;​​Ifcontourstarttop,
Set[
]
;​​Ifcontourstartright,
Set[
]
;​​contourstart=contourend;​​w=Map[ZP,box];​​(*ComputeZPatfourcorners*)​​countzetapzerosinbox=Round[(Arg[w[[2]]/w[[1]]]+Arg[w[[3]]/w[[2]]]+Arg[w[[4]]/w[[3]]]+Arg[w[[1]]/w[[4]]])/(2Pi)];​​ (*EndWhile*)​​;​​ll=box[[2]];​​ur=box[[4]];​​zetapzerosinbox=Select[rhoprime,(Re[ll]-delta/2<Re[#]&&Re[#]<Re[ur]+delta/2&&Im[ll]-delta/2<Im[#]&&Im[#]<Im[ur]+delta/2)&];​​If[Length[zetapzerosinbox]>1,delta=delta/2;Print[" recomputing... jj=",jj];Goto[redojjevaluation]];​​If[Length[zetapzerosinbox]==1,​​index=Flatten[Position[rhoprime,zetapzerosinbox[[1]]]][[1]];​​AppendTo[rhoprimetypes[[index]],jj],​​rrpp=s/.FindRoot[ZetaPrime[s],{s,(ll+ur)/2},WorkingPrecision->30,AccuracyGoal->5];​​AppendTo[extrarhoprime,rrpp];​​AppendTo[extratypes,{jj}]​​];​​(*Nextzero*)​​Label[abortjjevaluation];​​Clear[ZP];​​monitor++​​,{jj,1,Length[gamma]},monitor

CITE THIS NOTEBOOK

Level curves for Zhang's Eta function​
by Jeffrey Stopple​
Wolfram Community, STAFF PICKS, October 25, 2026
​https://community.wolfram.com/t/28435