新規更新December 31, 2017 at 03:16AM
【外部リンク】
Convergencia de la función zeta de Riemann
Huseche: Página creada con « ==Introducción== <p> Desde 1859, año en que Bernhard Riemann calculó los primeros ceros de la Función zeta, se esperaba que sucediera una de dos opciones: *Qu…»
==Introducción==
<p>
Desde 1859, año en que [[Bernhard Riemann]] calculó los primeros ceros de la [[Función zeta]], se esperaba que sucediera una de dos opciones:
*Que alguien entregara una demostración de la [[Hipótesis de Riemann]], o en su defecto,
*Que alguien encontrara un [[Contraejemplo]] de la misma.
</p>
<p>
En noviembre de 2017, en el marco del '''X Seminario Internacional de Matemática Aplicada''', llevado a cabo en la [[Universidad Surcolombiana]] en Neiva (Huila, Colombia), se presentó la ponencia titulada '''Convergencia de la Función Z de Riemann''', en la cual, el autor, entrega una cantidad abundante de contraejemplos de la Conjetura de Riemann, y propone condiciones '''necesarias y suficientes''' para la convergencia de la serie involucrada en el cálculo de la función zeta de Riemann y de sus ceros. Este artículo resume los aspectos más relevantes de dicha ponencia y los documentos asociados con la misma.
</p>
[[File:Ceros reflex.png |frame|tamaño 814x785px| right|Póster reseñando la realización del X Seminario Internacional de Matemática Aplicada que sirvió de marco para la presentación de la ponencia acerca de la convergencia de los ceros de la función zeta de Riemann]]
*Programación oficial: http://ift.tt/2lzucmf
<p>
==La función zeta de Riemann (nueva expresión)==
La función Z de Riemann, se define (Euler, 1737) como:
<math>
\zeta(s)=\sum_{n=1}^{\infty}\frac{1}{n^s}
</math>
donde <math>s\in \mathbb C</math>. Con <math>s=a+bi</math>. Esta función es especial, en muchos sentidos, sin embargo, aquí, solo nos referimos a su papel en la convergencia de los denominados '''ceros de la función Z de Riemann''' <math>\zeta</math>.
La expresión para <math>\zeta(s)</math>, dada arriba, no es computable, por lo que, primero es necesario derivar una ecuación computable que pueda ser usada para calcular los '''ceros de la función Z'''.
Usando esta definición, se obtiene la siguiente expresión:
<math>
\sum_{n=1}^{\infty}\frac 1{n^s}=\sum_{n=1}^{\infty}\frac{\cos(b\ln n)}{n^a}-i\sum_{n=1}^{\infty}\frac{\sin(b\ln n)}{n^a}
</math>
que es una expresión computable para <math>\zeta(s)</math>, donde se puede diferenciar claramente sus componentes real e imaginario.
===Demostración===
Sea dada la función Z de Riemann, definida como aparece arriba, donde <math>s\in \mathbb C</math>, haciendo <math>s=a+bi</math> y sustituyendo en <math>\zeta(s)</math>, se tiene:
<math>
\begin{align}
\frac 1{n^s}&=n^{-(a+bi)}=n^{-a}n^{-bi}\\
\frac 1{n^s}&=n^{-a}e^{\ln{n^{-bi}}}=n^{-a}e^{-bi\ln n}=n^{-a}e^{i(-b\ln n)}
\end{align}
</math>
haciendo <math>\theta=-b\ln n</math>, y sabiendo que <math>e^{i\theta}=\cos\theta+i\sin\theta</math> la ecuación anterior se transforma en:
<math>
\begin{align}
\frac 1{n^s}&=n^{-a}e^{i\theta}=n^{-a}[\cos\theta+i\sin\theta]\\
\frac 1{n^s}&=n^{-a}[\cos(-b\ln n)+i\sin(-b\ln n)]
\end{align}
</math>
ahora, puesto que <math>cos(-\theta)=\cos\theta</math> y <math>\sin(-\theta)=-\sin\theta</math>, se tiene:
<math>
\begin{align}
\frac 1{n^s}&=n^{-a}\cos(b\ln n)-in^{-a}\sin(b\ln n)\\
\frac 1{n^s}&=\frac{\cos(b\ln n)}{n^a}-i\frac{\sin(b\ln n)}{n^a}
\end{align}
</math>
introduciendo la sumatoria de la definición de <math>\zeta</math>, se puede escribir:
<math>
\begin{align}
\sum_{n=1}^{\infty}\frac 1{n^s}&=\sum_{n=1}^{\infty}\left(\frac{\cos(b\ln n)}{n^a}-i\frac{\sin(b\ln n)}{n^a}\right)
\end{align}
</math>
finalmente, por una propiedad de las sumatorias, se llega a:
<math>
\zeta(s)=\sum_{n=1}^{\infty}\frac 1{n^s}=\sum_{n=1}^{\infty}\frac{\cos(b\ln n)}{n^a}-i\sum_{n=1}^{\infty}\frac{\sin(b\ln n)}{n^a}
</math>
La ecuación anterior es perfectamente computable y, su comportamiento puede ser analizado con la
ayuda del siguiente fragmento de código, escrito en [[Go (lenguaje de programación)]] de [[Google]]:
<source lang=C>
func Riemann_cmp(precision int,p_real,p_img float64)
(float64,float64){
var n,i int
var a,b,ang,sen,cos,pr float64
var fre,fcmp,cmp,re,sumac,sumar float64
//fmt.Println("====Funcion Riemann Compleja ======")
//fmt.Printf("Tiempo antes de ejecutar: %v \n",time.Now())
n=precision
a=p_real
b=p_img
sumar=0
sumac=0
for i=1;i<=n;i++{
ang=b*math.Log(float64(i))
sen=math.Sin(ang)
cos=math.Cos(ang)
pr=math.Pow(float64(i),a)
fre=cos/pr
fcmp=sen/pr
re=fre+sumar
cmp=fcmp+sumac
//fmt.Printf("I=%d re: %g imag: %g\n",i,re,cmp)
sumar=re
sumac=cmp
}
//fmt.Printf("Tiempo después de ejecutar: %v \n",time.Now())
return re,cmp
}
</source>
La función toma tres argumentos con el siguiente significado:
* El parámetro '''precision''' representa el número de términos que se involucran en la sumatoria de <math>\zeta(s)</math>, para lograr su convergencia. Un valor muy bajo (<math><1000</math>)
puede ser insuficiente y un valor muy alto (<math> >1000000</math>) hace que se retarde la convergencia.
* El parámetro '''p_real''' representa el valor real de <math>s</math>, es decir, <math>\Re{(s)}</math>.
* El parámetro '''p_img''' representa el valor imaginario de <math>s</math>, es decir, <math>\Im{(s)}</math>.
La función también devuelve dos valores en las variables '''re''' y '''cmp''', que representan respectivamente,
las partes real e imaginaria de la función <math>\zeta(s)</math>. La función '''Riemann_cmp()''', se ejecuta con la ayuda de una función '''main()''' de la siguiente forma
<source lang=C>
func main() {
var precision int
var p_real,p_img float64
precision=10000000
p_real=1.5
p_img=10.3
Riemann_cmp(precision,p_real,p_img)
}
</source>
donde se usan los valores <math>\Re(s)=1.5</math> y <math>\Im(s)=10.3</math> con un millón de términos para lograr la convergencia. El resultado de compilar y ejecutar esta rutina, se muestra a continuación:
<source lang=C>
.
.
.
I=999996 re: 1.2629451829358893 imag: 0.15253657032810491
I=999997 re: 1.2629451823364974 imag: 0.1525365695276436
I=999998 re: 1.2629451817371147 imag: 0.15253656872717733
I=999999 re: 1.262945181137741 imag: 0.15253656792670608
I=1000000 re: 1.2629451805383765 imag: 0.15253656712622987
</source>
donde, por comodidad, sólo se ilustran los últimos 5 valores en la salida, la cual permite apreciar que <math>\zeta(1.5 , 10.3)=1.26294518+i\, 0.152536567</math>, es decir,
que <math>\zeta(s)</math> converge para valores de <math>\Re(s)</math> mayores a 1.
Ahora bien, evaluando de nuevo la función '''Riemann_cmp()''', pero esta vez usando los valores <math>\Re(s)=0.5</math> y <math>\Im(s)=10.3</math> con diez millones de términos,
el resultado es el siguiente:
<source lang=C>
.
.
.
I=991003 re: -73.08429226631614 imag: 61.472730311215976
I=991004 re: -73.08496647510914 imag: 61.471985650107754
I=991005 re: -73.0856406758223 imag: 61.4712409823679
I=991006 re: -73.08631486845559 imag: 61.47049630799651
.
.
.
I=999997 re: -78.81479813815487 imag: 54.5185409587966
I=999998 re: -78.81539751976084 imag: 54.51774049412503
I=999999 re: -78.81599689282228 imag: 54.5169400236801
.
.
.
I=9999995 re: 132.02025846068926 imag: 277.73604962072875
I=9999996 re: 132.01997914977514 imag: 277.7361978956533
I=9999997 re: 132.01969983872223 imag: 277.73634617028273
I=9999998 re: 132.01942052753057 imag: 277.73649444461705
I=9999999 re: 132.01914121620015 imag: 277.73664271865624
I=10000000 re: 132.01886190473098 imag: 277.73679099240036
Tiempo después de ejecutar: 2017-05-21 16:32:20.9620112 -0500
</source>
donde se puede apreciar que la función NO converge, como lo indica la teoría.
==La extensión analítica de <math>\zeta</math>==
La función <math>\zeta</math> de Riemann, tal y como aparece definida arriba, no converge para valores en el intervalo <math>0< \Re(s) <1</math>, y por tanto, no es analítica
en dicho intervalo. Se necesita una expresión de <math>\zeta</math> que pueda converger para <math>0< Re(s)<1</math>. A dicha expresión se le denomina la '''extensión analítica de''' <math>\zeta(s)</math> y se define como (véase Referencias No 3, Pág. 3):
<math>
\hat\zeta(s)=\frac{1}{1-2^{1-s}}\sum_{n=1}^{\infty}\frac{(-1)^{n-1}}{n^s}
</math>
donde está claro que hay un factor que no puede anularse. Por consiguiente, si <math>\hat\zeta(s)</math> se anula, lo será únicamente en virtud del
término <math>\sum_{n=1}^{\infty}\frac{(-1)^{n-1}}{n^s}</math>, el cual, como se observa fácilmente, es susceptible de anularse. Es decir, con estos ajustes la expresión definitiva, para buscar los ceros de la función <math>\zeta</math>, toma la forma:
<math>
\hat\zeta(s)=\sum_{n=1}^{\infty}\frac{(-1)^{n-1}\cos(b\ln n)}{n^a}-i\sum_{n=1}^{\infty}\frac{(-1)^{n-1}\sin(b\ln n)}{n^a}
</math>
que es la forma computable usada para encontrar los ceros funcionales de <math>\zeta</math>, donde está claro que '''la expresión se anula si y solo si sus partes real e imaginaria, se anulan''', es decir:
<math>
\begin{align}
\sum_{n=1}^{\infty}\frac{(-1)^{n-1}\cos(b\ln n)}{n^a}=0\\
\sum_{n=1}^{\infty}\frac{(-1)^{n-1}\sin(b\ln n)}{n^a}=0
\end{align}
</math>
==Los ceros de la función <math>\hat\zeta</math>==
[[Bernhard Riemann]] fue el primero en calcular dichos ceros, por allá en el año 1859,
obteniendo los primeros tres ceros de <math>\hat\zeta</math>, a saber:
<math>
\begin{align}
0.5 + 14.135\\
0.5 + 21.022\\
0.5 + 25.011
\end{align}
</math>
lo que sin duda debió ser una proeza notable considerando la dificultad del cálculo y el hecho de que Riemann no contaba con calculadoras ni computadoras.
Para computar la función <math>\hat\zeta(s)</math>, y buscar sus ceros funcionales, se puede emplear el siguiente fragmento de código Go:
<source lang=C>
func RiemannSerie(precision int,p_real,p_img
float64)(float64,float64){
// calcula al serie de Riemann con extension analitica
var n,i int
var a,b,ang,sen,cos,pr float64
var fre,fcmp,cmp,re,sumac,sumar float64
var bas,fac float64
n=precision
sumar=0
sumac=0
bas=-1.0
a=p_real
b=p_img
for i=1;i<n;i++{
ang=b*math.Log(float64(i))
sen=math.Sin(ang)
cos=math.Cos(ang)
pr=math.Pow(float64(i),a)
fac=math.Pow(bas,float64(i-1))
fre=fac*(cos/pr)
fcmp=fac*(sen/pr)
re=fre+sumar
cmp=fcmp+sumac
sumar=re
sumac=cmp
}
return re,cmp
}
</source>
donde los parámetros y los valores devueltos conservan el significado explicado anteriormente.
Evaluando esta función para <math>\zeta(1/2,10.3)</math>, es decir, los valores usados anteriormente (los cuales no convergen en la función <math>\zeta(s)</math> sin extender analíticamente) se consigue:
<source lang=C>
I=999992 re: 1.2629451853335487 imag: 0.15253657352990038
I=999993 re: 1.2629451847341202 imag: 0.15253657272945897
I=999994 re: 1.2629451841347008 imag: 0.1525365719290126
I=999995 re: 1.2629451835352905 imag: 0.15253657112856125
I=999996 re: 1.2629451829358893 imag: 0.15253657032810491
I=999997 re: 1.2629451823364974 imag: 0.1525365695276436
I=999998 re: 1.2629451817371147 imag: 0.15253656872717733
I=999999 re: 1.262945181137741 imag: 0.15253656792670608
I=1000000 re: 1.2629451805383765 imag: 0.15253656712622987
</source>
donde, después de un millón de sumas, la función converge, como era de esperar.
Con estas herramientas y considerando que, por vez primera en la historia de este problema, se cuenta con una expresión directamente computable en el plano complejo, lo cual
permite hacer un barrido en el plano, en el intervalo <math>0< \Re(s)<1</math>, se procede de esta forma a calcular los primeros ceros en la recta <math>\Re(s)=1/2</math>,
que se muestran en la tabla 1.
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<big>'''Tabla 1: Primeros seis ceros en la recta <math>\Re(s)=0.5</math>'''</big>
! No !! <math>\Re(s)</math> !! <math>\Im(s)</math> !! <math>\Re(\zeta(s))</math> !! <math>\Im(\zeta(s))</math> !! Norma(<math>\zeta(s)</math>
|-
| 1|| 0.5 || 14.13 || -0.0000527 || 0.0090912 || 0.0000826
|-
| 2|| 0.5 || 21.02 || 0.01280955 || 0.0254116 || 0.00080983
|-
| 3|| 0.5 || 25.01 || -0.0007136 || 0.0015427 || 0.00000288
|-
| 4|| 0.5 || 30.42 || 0.00041551 || 0.0135421 || 0.00018356
|-
| 5|| 0.5 || 32.93 || 0.00090074 || 0.0156852 || 0.00024683
|-
| 6|| 0.5 || 37.58 || 0.01206027 || 0.0050403 || 0.00017085
|}
Los ceros que muestra la tabla 1, han sido calculados usando una variante de la función ''RiemannSerie()'', que a continuación se cita:
<source lang=C>
func SearchContraExample(delta float64,iCeros int,p_real float64) {
var precision,num_ceros int
var p_img, gap,ant_img float64
f, err := os.Create("d:/devgo/projects/riemann/search_riemann_backsamples.txt")
check(err)
f.WriteString(fmt.Sprintf("================Función SearchContraExample =================\n"))
f.WriteString(fmt.Sprintf("Busca los ceros de Riemann con parte real arbitraria\n"))
f.WriteString(fmt.Sprintf("Tiempo antes de inciar: %v \n",time.Now()))
precision=1000000
p_img=145.0
num_ceros=0;
for i:=0; ;i++{
re,im:=RiemannSerie(precision,p_real,p_img)
norm:=re*re+im*im
if norm <0.01{
num_ceros++
gap=math.Abs(ant_img-p_img)
// muestra los ceros obtenidos en la salida estándar
fmt.Printf("Iter: %d Cero No: %d Real: %g Img: %g re: %g img: %g norm: %g gap:%g\n",i,num_ceros,p_real,p_img,re,im,norm,gap)
// salva los ceros obtenidos en un archivo de texto
f.WriteString(fmt.Sprintf("Iter: %d Cero No: %d Real: %g Img: %g re: %g img: %g norm: %g gap:%g precision:%d\n",i,num_ceros,p_real,p_img,re,im,norm,gap,precision))
ant_img=p_img
}
p_img+=delta;
if(num_ceros==iCeros){break}
}
f.WriteString(fmt.Sprintf("Tiempo despues de calcular: %v \n",time.Now()))
defer f.Close()
}
</source>
en la rutina anterior, por brevedad, se emplea un millón de términos. Siguiendo este procedimiento, es fácil hacer un
barrido en el plano complejo, encontrando la existencia de '''numerosas rectas conteniendo ceros''', las cuales se listan en la tabla 7.
Los rectas ilustradas en la tabla 7, corresponden a las rectas encontradas a la fecha y de ninguna manera (véase nota [1]) agotan las posibilidades de hallar más rectas conteniendo ceros funcionales de <math>\hat\zeta</math>. Es curioso notar que en la franja <math>0<\Re(s)<0.43</math> no hay ceros! (véase nota [2]) por lo que, el radio de investigación se limita al intervalo <math>0.43 \leq \Re(s) < 1</math>.
Para ilustrar mejor el asunto, se presentan más contraejemplos de la [[Hipótesis de Riemann]], en las tablas 2, 3, 4, 5 y 6 (véase nota [3]).
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<big>'''Tabla 2: Primeros diez ceros en la recta <math>\Re(s)=0.47</math>'''</big>
! No !! <math>\Re(s)</math> !! <math>\Im(s)</math> !! <math>\Re(\zeta(s))</math> !! <math>\Im(\zeta(s))</math> !! Norma(<math>\zeta(s)</math>
|-
|1|| 0.47 || 14.09 ||-0.0591769 || 0.0650853 || 0.0077380
|-
|2|| 0.47 || 21.0 || -0.0385952 || 0.0807528 || 0.0080106
|-
|3|| 0.47 || 25.0 || -0.0722184 ||-0.0231961 || 0.0057535
|-
|4|| 0.47 || 37.6 || -0.0582022 || 0.0493030 || 0.0058182
|-
|5|| 0.47 || 48.0 || -0.0977008 || 0.0085135 || 0.0096179
|-
|6|| 0.47 || 72.1 || 0.07315905 || -0.023483 || 0.0059037
|-
|7|| 0.47 || 127.49 || 0.043323 || 0.0839421 || 0.0089232
|-
|8|| 0.47 || 145.99 || -0.04931 || 0.0779763 || 0.0085118
|-
|9|| 0.47 || 162.99 || 0.006458 || -0.084969 || 0.0072615
|-
|10|| 0.47 || 185.59 || -0.0800499 || 0.0508676 || 0.008995
|}
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<big>'''Tabla 3: Primeros diez ceros en la recta <math>\Re(s)=0.53</math>'''</big>
! No !! <math>\Re(s)</math> !! <math>\Im(s)</math> !! <math>\Re(\zeta(s))</math> !! <math>\Im(\zeta(s))</math> !! Norma(<math>\zeta(s)</math>
|-
|1|| 0.53 || 14.09 ||0.0532608 || 0.0655659 || 0.0071356
|-
|2|| 0.53 || 21.0 ||0.0827857 || 0.0135426 || 0.0070368
|-
|3|| 0.53 || 25.0 || 0.0396154 ||0.0595324 ||0.0051134
|-
|4|| 0.53 || 37.6 ||0.0015760 ||-0.0701232 ||0.0049197
|-
|5|| 0.53 || 48.0 ||0.0863803 ||0.0209932 || 0.0079022
|-
|6|| 0.53 || 72.1 ||0.0279098 ||0.0591989 ||0.0042834
|-
|7|| 0.53 || 127.49 ||0.0431644 ||-0.0670067 || 0.0063530
|-
|8|| 0.53 || 145.99 ||0.0491745 ||-0.0637075 || 0.00647677
|-
|9|| 0.53 || 162.99 ||-0.0682554||-0.00551149 ||0.00468918
|-
|10|| 0.53 || 185.59 ||0.0701395 ||-0.0462074 ||0.00705468
|}
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<big>'''Tabla 4: Primeros diez ceros en la recta <math>\Re(s)=0.67</math>'''</big>
! No !! <math>\Re(s)</math> !! <math>\Im(s)</math> !! <math>\Re(\zeta(s))</math> !! <math>\Im(\zeta(s))</math> !! Norma(<math>\zeta(s)</math>
|-
|1 || 0.67 || 24909.79 || -0.0606782 || 0.0600306 || 0.0072855
|-
|2 || 0.67 || 31572.389 || 0.0316965 || -0.0512341 || 0.0036296
|-
|3 || 0.67 || 31612.289 || -0.032057 || 0.03950699 || 0.0025884
|-
|4 || 0.67 || 31635.689 || -0.023354 || -0.0502781 || 0.0030733
|-
|5 || 0.67 || 31698.989 || -0.080725 || 0.01138963 || 0.0066462
|-
|6 || 0.67 || 31738.389 || -0.031640 || 0.01820720 || 0.0013326
|-
|7 || 0.67 || 31834.689 || 0.0047814 || 0.00877299 || 0.0000998
|-
|8 || 0.67 || 31897.889 || -0.025277 || 0.09119049 || 0.0089546
|-
|9 || 0.67 || 32099.889 || 0.0614658 || -0.0536483 || 0.0066561
|-
|10 || 0.67 || 32115.789 || -0.079928 || -0.0224789 || 0.0068938
|}
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<big>'''Tabla 5: Primeros ocho ceros en la recta <math>\Re(s)=0.87</math>'''</big>
! No !! <math>\Re(s)</math> !! <math>\Im(s)</math> !! <math>\Re(\zeta(s))</math> !! <math>\Im(\zeta(s))</math> !! Norma(<math>\zeta(s)</math>
|-
|1|| 0.87 || 163.09 || -0.0676011 || 0.0671348 || 0.0090769
|-
|2|| 0.87 || 163.19 || -0.0954539 || 0.0124029 || 0.0092652
|-
|3|| 0.87 || 489.5 || -0.09741049 || 0.0012685 || 0.0094904
|-
|4|| 0.87 || 580.1 || -0.08082229 || 0.0441122 || 0.0084781
|-
|5|| 0.87 || 861.1 || -0.05650421 || 0.0630962 || 0.0071738
|-
|6|| 0.87 || 861.2 || -0.09047824 || 0.0168424 || 0.0084699
|-
|7|| 0.87 || 1586.29 || -0.085475 || -0.045788 || 0.0094025
|-
|8|| 0.87 || 2039.49 || -0.055274 || 0.0791788 || 0.0093245
|}
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<big>'''Tabla 6: Primeros diez ceros en la recta <math>\Re(s)=0.99</math>'''</big>
! No !! <math>\Re(s)</math> !! <math>\Im(s)</math> !! <math>\Re(\zeta(s))</math> !! <math>\Im(\zeta(s))</math> !! Norma(<math>\zeta(s)</math>
|-
|1|| 0.99 || 18.1 || -0.0164294 || 0.0364413 || 0.0015978
|-
|2|| 0.99 || 18.2 || 0.00285045 || -0.0909336 || 0.0082770
|-
|3|| 0.99 || 27.2 || -0.0152707 || -0.0044461 || 0.0002529
|-
|4|| 0.99 || 36.2 || -0.0382743 || 0.06136275 || 0.00523031
|-
|5|| 0.99 || 36.3 || 0.01150310 || -0.0476188 || 0.00239987
|-
|6|| 0.99 || 45.3 || -0.0080385 || 0.04103830 || 0.00174876
|-
|7|| 0.99 || 54.4 || -0.0151023 || -0.0125667 || 0.00038600
|-
|8|| 0.99 || 63.4 || -0.0358817 || 0.08598499 || 0.0086809
|-
|9|| 0.99 || 63.5 || 0.00911311 || -0.0802903 || 0.00652958
|-
|10|| 0.99 || 72.4 || 0.03995582 || 0.07647096 || 0.00744427
|}
Para mayor ilustración de estas tablas, se pueden consultar los documentos 1 y 2 de la sección de Referencias. Igualmente, el lector interesado puede descargar todos
los documentos y resultados numéricos asociados con esta investigación en la sección de '''Enlaces externos'''. En consecuencia, habiendo presentado suficiente ilustración, se puede afirmar que:
<code>'''<big>La Hipótesis de Riemann es falsa!</big>'''</code>
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<small>''' Tabla 7: Rectas en el plano complejo cuyos valores de <math>\Re(s)</math> contienen ceros de la función <math>\hat\zeta</math>'''</small>
! No !! <math>\Re(s)</math> !! Detalle (densidad)
|-
|1|| 0.43 || escasos
|-
|2|| 0.44 || escasos
|-
|3|| 0.45 || escasos
|-
|4|| 0.47 || abundantes
|-
|5|| 0.49 || abundantes
|-
|6|| 0.5 || abundantes
|-
|7|| 0.51 || abundantes
|-
|8|| 0.55 || escasos
|-
|9|| 0.67 || abundantes
|-
|10|| 0.79 || escasos
|-
|11|| 0.84 || escasos
|-
|12|| 0.90 || abundantes
|-
|13|| 0.91 || abundantes
|-
|14|| 0.92 || abundantes
|-
|15|| 0.93 || abundantes
|-
|16|| 0.94 || abundantes
|-
|17|| 0.95 || abundantes
|-
|18|| 0.96 || abundantes
|-
|19|| 0.97 || abundantes
|-
|20|| 0.98 || abundantes
|-
|21|| 0.99 || abundantes
|}
Como se sabe, ''solo se requiere un contraejemplo para concluir que la conjetura o [[Hipótesis de Riemann]] es falsa'' y, en este documento, se ilustran abundantes contraejemplos en el
plano complejo (<math>0.43 < \Re(s) < 1</math>) los cuales respaldan la afirmación concluyente en relación con esta conjetura.
La tabla 7 muestra que, además de la conocida recta <math>\Re(s)=1/2</math>, se tiene una cantidad, finita pero abundante, de rectas en el plano complejo
conteniendo ceros de la función <math>\hat\zeta</math> de Riemann.
== Convergencia según número de términos==
Todos los ceros denunciados en las tablas 2, 3, 4, 5, y 6, por defecto, han sido calculados usando un millón de términos en las sumatorias involucradas, considerando que con dicha cifra se consigue
una tendencia definitiva e irreversible como se puede apreciar en la tabla 8, la cual muestra las variaciones en los resultados cuando se utilizan diferentes valores para la precisión de los cálculos, esto es, un número cada vez mayor de términos en la sumatoria de la serie involucrada.
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<small>'''Tabla 8: Convergencia del cero <math>\hat\zeta(0.9+163.2i)</math> variando el número de términos hasta llegar al límite práctico de procesamiento con un ordenador personal'''</small>
! No Términos !!<math>\Re(\hat\zeta(s))</math> !! <math>\Im(\hat\zeta(s))</math> !! Norma <math>\hat\zeta(s)</math>
|-
|1000|| -0.077687558742 || 0.0024792659894 || 0.0060415035432
|-
|10000|| -0.076826587677 || 0.0020653409607 || 0.0059065902074
|-
|100000|| -0.076827833536 || 0.0019445412501 || 0.0059062972465
|-
|1000000|| -0.076842084438 || 0.0019391964805 || 0.0059084664238
|-
|10000000|| -0.076843349624 || 0.0019406357055 || 0.0059086664484
|-
|100000000|| -0.076843236509 || 0.0019408487881 || 0.0059086498912
|-
|1000000000|| -0.076843206380 || 0.0019408449579 || 0.0059086452460
|-
|10000000000|| -0.076843205489 || 0.0019408412396 || 0.0059086450946
|}
La tabla 8 muestra que después de diez mil millones de sumatorias, el cero, <math>\hat\zeta(0.9+163.2i)=0</math>, se sostiene y la norma converge a <math>0.0059086</math> y puesto que el
aporte de términos superiores es mínimo y despreciable, no hay razones para pensar que la tendencia se invierta.
==Ceros gemelos (Twin zeros)==
De manera similar a lo que sucede con los [[Números primos gemelos]] (twin primes), en el caso de los ceros de Riemann, también se presenta un
fenómeno que podríamos denominar '''ceros gemelos''' ('''twin zeros''') como se ilustra en la tabla 9.
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<small>'''Tabla 9: Twin zeros o ceros gemelos en la convergencia de la función <math>\hat\zeta</math>'''</small>
! No || <math>\Re(s)</math> || <math>\Im(s)</math>
|-
|1|| 0.9 || 163.1
|-
|1|| 0.9 || 163.2
|-
|2|| 0.9 || 580.1
|-
|2|| 0.9 || 580.2
|-
|3|| 0.87 || 163.09
|-
|3|| 0.87 || 163.19
|-
|4|| 0.87 || 861.1
|-
|4|| 0.87 || 861.2
|-
|5|| 0.45 || 1329.09
|-
|5|| 0.45 || 1329.19
|}
Se pueden definir los ceros gemelos como '''aquellos ceros que estando en la misma recta difieren en su parte imaginaria por no más de una unidad'''. El otro aspecto
importante con estos ceros es que son '''infinitos''', como en el caso de los primos gemelos, aunque por el momento no existe una demostración de este hecho (véase siguiente sección).
==Existencia de infinitos ceros==
Desde los trabajos de [[Godfrey Harold Hardy]], se sabe que existen infinitos ceros de Riemann, al menos en la recta <math>\Re(s)=1/2</math> para la cual Hardy entregó una demostración. No obstante, la información obtenida sobre la densidad de los ceros en las rectas de la tabla 7, es escasa y por el momento sólo se puede suponer que son infinitos, aunque por el momento no existe una demostración de este hecho, pero a juzgar por los avances obtenidos en la materia, se cree que una demostración en este sentido no tardará en llegar.
Algo similar se puede afirmar en relación al número de rectas que contienen ceros no triviales (<math>\Re(s)=0.99, \Re(s)=0.98, \Re(s)=0.97, \Re(s)=0.90, \Re(s)=0.87, \Re(s)=0.84, \Re(s)=0.79, \Re(s)=0.75</math>, etc).
Por ahora, su número es moderado aunque abundante, lo cierto es que en el intervalo <math> 0.42<\Re(s)<1 </math> parece haber '''regiones''' privilegiadas que presentan estas rectas, pero de otra parte, también hay regiones en las cuales no se han encontrado rectas que entreguen ceros funcionales de <math>\hat\zeta</math>, en parte por la dificultad de hallarlas y en parte porque, quizá, no existan.
==Los ceros por reflexión==
Como lo ilustró el propio Riemann, <math>\zeta(s)</math> se extiende en <math>\mathbb{C}</math> como una función meromórfica por continuación analítica, a
través de la expresión conocida como [[Ecuación funcional]] de la función zeta:
<math>
\pi^{-s/2}\Gamma(\frac s2)\zeta(s)=\pi^{-(1-s)/2}\Gamma(\frac{1-s}2)\zeta(1-s)
</math>
la cual tiene un polo simple en <math>s=1</math>, con residuo 1. La '''ecuación funcional''' involucra una función gamma (<math>\Gamma</math>) definida como:
<math>
\Gamma(s)=\int_{0}^{\infty} t^{s-1}e^{-t}dt, \quad\Re(s)\leq 0
</math>
la cual no tiene ceros. Puesto que <math>\pi^{-(1-s)/2}</math> es un término diferente de cero, y la función gamma no entrega ceros, se tiene entonces que para valores de <math>\Re(s)\leq \frac 12</math>,
si existe un cero en <math>\zeta(s)</math>, se sigue inmediatamente desde la '''ecuación funcional''' que dicho cero se debe reflejar en <math>1-s</math>, es decir, <math>\zeta(1-s)=0</math>, con lo cual, por cada cero en la
franja <math>0<\Re(s)\leq \frac 12</math>, habrá otro cero en la franja <math>\frac 12 \leq\Re(s)< 1</math>, en palabras, los ceros a la izquierda de la recta <math>\Re(s)=\frac 12</math>, se reflejan a la derecha de la
misma recta. Lo contrario, sin embargo, no es cierto, como se verá a continuación.
Entonces, sea dado <math>z_{0^-}=\sigma+it</math> un cero de <math>\hat\zeta(s)</math>, con <math>0<\sigma\leq 1/2</math>, se denominan '''ceros por reflexión''' a los ceros obtenidos en
<math>z_{0^+}=1-\sigma+it</math>. En nuestro caso, el primer cero aparece en la recta <math>\Re(s)=0.43</math>, siendo <math>\zeta(0.43+1977.19\,i)=0</math>, y de acuerdo con lo establecido
se debe tener un cero reflejado en <math>\zeta(0.57+1977.19\,i)=0</math>, para verlo, se muestra la salida de la rutina '''SearchContraExample()''', en la vecindad del cero citado:
<source lang=C>
Real: 0.57 Img: 1977.19 re: 0.0364 img: -0.0382 norm: 0.0027
</source>
donde la salida se ha formateado un poco con el fin de hacerla presentable.
La teoría presentada aquí cumple cabalmente con esta predicción que se desprende de la '''ecuación funcional''', y por vez primera, desde 1859, podemos verificar la autenticidad de este
hecho detallando la tabla 9, la cual ilustra un resumen de la situación, con algunos de los ceros involucrados.
{| border="0" style="background:#ffffff" align="top" class="wikitable"
|+ align="center" style="background:blue; color:white"|<small>'''Tabla 11: Ceros por reflexión en <math>\zeta(\sigma+it)=0</math>'''</small>
! Recta || <math>\zeta(\sigma)=0</math> || <math>\zeta(1-\sigma)=0</math>
|-
|0.43 || 0.43+1977.19i || 0.57+1977.19i
|-
|0.44 || 0.44+1977.19i || 0.56+1977.19i
|-
|0.45 || 0.45+1329.09i || 0.55+1329.09i
|-
|0.45 || 0.45+1415.59i || 0.55+1415.59i
|-
|0.46 || 0.46+25.0i || 0.54+25.0i
|-
|0.46 || 0.46+37.6i || 0.54+37.6i
|-
|0.47 || 0.47+14.09i || 0.53+14.09i
|-
|0.47 || 0.47+21.0i || 0.53+21.0i
|-
|0.48 || 0.48+14.09i || 0.52+14.09i
|-
|0.48 || 0.48+21.0i || 0.52+21.0i
|-
|0.49 || 0.49+14.09i || 0.51+14.09i
|-
|0.49 || 0.49+21.0i || 0.51+21.0i
|}
Por supuesto, no es posible presentar todos los casos, pero para quienes tengan un mayor interés pueden consultar los documentos de la sección de '''Referencias'''.
Los ceros por reflexión, no son los únicos ceros que existen en la franja <math>\frac 12\leq\Re(s)<1</math>. En efecto, hay otros ceros en esta franja que son exclusivos, es decir, que no tienen un reflejo
en la franja <math>0<\Re(s)\leq\frac 12</math> y por obvia razón se denominan '''ceros exclusivos'''. Ejemplos de estos ceros son los encontrados en las rectas <math>\Re(s)=0.90, 0.91, 0.92, \dots , 0.99</math>.
Un detalle importante es que, algunos ceros exclusivos, se encuentran en rectas donde también convergen ceros reflejados! Otro misterio más de la función <math>\zeta</math>.
==Criterios de convergencia==
Sea <math>z=a+bi</math> un complejo no nulo, esto es, <math>z\neq 0</math> y sea <math>\big| z\big| = \sqrt{a^2+b^2}</math> su norma. También, considere a <math>z_0</math>
como un cero de <math>\hat\zeta(s)</math>, es decir, <math>\hat\zeta(z_0)=0</math>. El siguiente criterio permitirá explorar los ceros de la función <math>\hat\zeta</math>:
'''La norma de <math>\hat\zeta(z)</math> tiende a cero, cuando <math>z</math> tiende a <math>z_0</math>'''
En lenguaje metemático <math>| \hat\zeta(z)| \longrightarrow 0</math> si y solo si <math>z\longrightarrow z_0</math>. Tanto más se aproxima
<math>z</math> a <math>z_0</math>, tanto más se aproximará <math>| \hat\zeta(z)|</math> a cero.
La demostración de este hecho es obvia desde la expresión para <math>\hat\zeta</math>, se consigue:
<math>
\begin{align}
\big| \hat\zeta(z_0)\big| &=\sqrt{\left(\sum_{n=1}^{\infty}\frac{(-1)^{n-1}\cos(b\ln n)}{n^a}\right)^2+\left(\sum_{n=1}^{\infty}\frac{(-1)^{n-1}\sin(b\ln n)}{n^a}\right)^2}\\
\big| \hat\zeta(z_0)\big| &=\sqrt{0^2+0^2}\\
\big| \hat\zeta(z_0)\big| &=0
\end{align}
</math>
dado que <math>z_0</math> es un cero de <math>\hat\zeta(s)</math>.
Este hecho puede ser explotado a la hora de calcular en serie todos los ceros de la función <math>\hat\zeta</math>.
Para verlo con mayor claridad, considere un ejemplo numérico. Tómese el primer cero de la función, esto es, <math>\hat\zeta(z_0)=0</math> para <math>z_0=</math> 0.5+14.135i. Primero asuma que,
de este cero se conoce solamente su parte entera, esto es, 14. Se requiere hacer converger la parte decimal y para ello simplemente se cálcula la norma para los valores 14.1, 14.2, 14.3, ... 14.9 y
'''se escoge el valor que más se aproxime a cero (el menor valor) como el valor representativo''', este valor entrega el primer decimal de <math>z_0</math>. Procediendo de esta manera se consigue:
<source lang=C>
i=0 re: 0.0123 im: 0.252 b= 14 norm: 0.06356051094769553
i=1 re: -0.00163 im: 0.0653 b= 14.1 norm: 0.004267063680288036
i=2 re: 0.0141 im: -0.122 b= 14.2 norm: 0.015010324186883877
i=3 re: 0.0601 im: -0.305 b= 14.3 norm: 0.09678257573736752
i=4 re: 0.137 im: -0.48 b= 14.4 norm: 0.24907275250510502
i=5 re: 0.242 im: -0.64 b= 14.5 norm: 0.46854448768625373
i=6 re: 0.373 im: -0.782 b= 14.6 norm: 0.7502633926958582
i=7 re: 0.526 im: -0.902 b= 14.7 norm: 1.089577972938231
i=8 re: 0.699 im: -0.996 b= 14.8 norm: 1.4810462022747748
i=9 re: 0.888 im: -1.06 b= 14.9 norm: 1.9157712005434449
</source>
analizando los cálculos se observa que para <math>i=1</math> se consigue un valor parcial para la norma=0.0042670, lo cual indica que el primer dígito decimal del valor buscado es 1. Ahora,
para conseguir el segundo dígito decimal, se repite este ejercicio pero partiendo del valor parcial 14.1, con lo cual se consigue:
<source lang=C>
i=0 re: -0.00163 im: 0.0653 b= 14.1 norm: 0.004267063680288036
i=1 re: -0.0014 im: 0.0466 b= 14.11 norm: 0.002170345257393568
i=2 re: -0.000874 im: 0.0278 b= 14.12 norm: 0.0007751457590326
i=3 re: -5.28e-05 im: 0.00909 b= 14.13 norm: 0.000082653025867
i=4 re: 0.00107 im: -0.00964 b= 14.14 norm: 0.0000940663056752
i=5 re: 0.00248 im: -0.0284 b= 14.15 norm: 0.00081058808603856
i=6 re: 0.0042 im: -0.0471 b= 14.16 norm: 0.002233412015026754
i=7 re: 0.00622 im: -0.0658 b= 14.17 norm: 0.00436370718280975
i=8 re: 0.00853 im: -0.0844 b= 14.18 norm: 0.00720259912087224
i=9 re: 0.0112 im: -0.103 b= 14.19 norm: 0.010751147951535013
</source>
y de nuevo, analizando estos valores se obtiene <math>i=3</math> con el parcial para la
norma=0.000082653 como el menor valor de la serie y con ello se consigue 14.13 como el parcial buscado. Ahora, nuevamente
se repite este procedimiento pero, esta vez, tomando 14.13 como punto de partida, para conseguir:
<source lang=C>
i=0 re:-5.28e-05 im:0.00909 b=14.13 norm: 8.265302586739142e-05
i=1 re:4.57e-05 im:0.00722 b=14.131 norm: 0.0000520987339106264
i=2 re:0.000147 im:0.00534 b=14.132 norm: 0.0000285847025611317
i=3 re:0.000252 im:0.00347 b=14.133 norm: 0.0000121121356834308
i=4 re:0.000359 im:0.0016 b=14.134 norm: 0.00000268223732143979
i=5 re:0.00047 im:-0.000275 b=14.135 norm: 0.000000296211581997
i=6 re:0.000583 im:-0.00215 b=14.136 norm: 0.000004955262522647
i=7 re:0.000699 im:-0.00402 b=14.137 norm: 0.000016660594031066
i=8 re:0.000819 im:-0.00589 b=14.138 norm: 0.000035413409701511
i=9 re:0.000941 im:-0.00777 b=14.139 norm: 0.000061214912708464
</source>
en donde para <math>i=5</math> se consigue un parcial de la norma=0.0000002962 que entrega
el tercer dígito decimal, con lo cual <math>z_0=0.5+14.135i</math>, continuando el proceso
se consiguen puros ceros, por consiguiente, la convergencia concluye.
Para lograr este resultado, se hizo la suposición de que la parte entera de <math>z_0</math> era un valor conocido. Sin embargo, se requiere conocer para que valores de <math>z</math> existe un cero de Riemann,
lo cual se consigue aplicando el mismo principio. Por ejemplo, para conocer los ceros que pueda haber entre los primeros 50 enteros naturales, se evalua la serie,
comenzando en el valor <math>\Im(z)=10</math> y procediendo sucesivamente hasta agotar el intervalo, consiguiendo el siguiente resultado:
<source lang=C>
D:\devgo\projects\riemann>go run riem_cmp.go
==========Función TestNormRiemann =========
Realiza una prueba sobre la norma de la serie ...
Tiempo antes de la prueba: 2017-05-22 14:38:38.5070943 -0500
i= 0 im: 10 norm: 1.7889776690881514
i= 1 im: 11 norm: 5.3098650268751655
i= 2 im: 12 norm: 6.768324648445004
i= 3 im: 13 norm: 3.4967826646143063
i= 4 im: 14 norm: 0.06356051094769553
i= 5 im: 15 norm: 2.381955939157363
i= 6 im: 16 norm: 6.452188324133802
i= 7 im: 17 norm: 4.568704007474071
i= 8 im: 18 norm: 0.9997764574506408
i= 9 im: 19 norm: 2.6713988912976956
i= 10 im: 20 norm: 2.945157748816574
i= 11 im: 21 norm: 0.002662873270821427
i= 12 im: 22 norm: 5.357107076667078
i= 13 im: 23 norm: 12.165704691861526
i= 14 im: 24 norm: 5.837743666058762
i= 15 im: 25 norm: 0.0006139721348228435
i= 16 im: 26 norm: 2.2110427862684428
i= 17 im: 27 norm: 1.2916684547596544
i= 18 im: 28 norm: 4.7464114975910885
i= 19 im: 29 norm: 8.593858281013109
i= 20 im: 30 norm: 1.4332421065034437
i= 21 im: 31 norm: 2.143418386822452
i= 22 im: 32 norm: 4.340379601242355
i= 23 im: 33 norm: 0.04002367855676915
i= 24 im: 34 norm: 8.416930281999235
i= 25 im: 35 norm: 9.441743044621148
i= 26 im: 36 norm: 1.5338090982539594
i= 27 im: 37 norm: 0.714128946288046
i= 28 im: 38 norm: 1.1286250787015908
i= 29 im: 39 norm: 12.50188357251842
i= 30 im: 40 norm: 9.276328458775254
i= 31 im: 41 norm: 0.08318423474708224
i= 32 im: 42 norm: 5.945272907345323
i= 33 im: 43 norm: 0.8871081282085561
i= 34 im: 44 norm: 2.50511811977559
i= 35 im: 45 norm: 2.5696115395314534
i= 36 im: 46 norm: 5.933446030271415
i= 37 im: 47 norm: 7.460767064095884
i= 38 im: 48 norm: 0.0002458165045608516
i= 39 im: 49 norm: 2.5955064410270676
i= 40 im: 50 norm: 0.6752034911191576
i= 41 im: 51 norm: 16.039741414193923
i= 42 im: 52 norm: 10.617457663722135
i= 43 im: 53 norm: 0.007145333447324516
i= 44 im: 54 norm: 1.4552950248016576
i= 45 im: 55 norm: 3.3168423949796426
i= 46 im: 56 norm: 2.054393784260305
i= 47 im: 57 norm: 4.846507797496249
i= 48 im: 58 norm: 16.290909889314573
i= 49 im: 59 norm: 1.6175687339978813
Tiempo despues de la prueba: 2017-05-22 14:38:50.0765802 -0500
</source>
Analizando estos resultados, se observa que, los valores para los cuales posiblemente existe un cero de Riemann son aquellos para los cuales <math>|z|<1</math>, estos son:
<source lang=C>
i= 4 im: 14 norm: 0.06356051094769553
i= 8 im: 18 norm: 0.9997764574506408
i= 11 im: 21 norm: 0.002662873270821427
i= 15 im: 25 norm: 0.0006139721348228435
i= 23 im: 33 norm: 0.04002367855676915
i= 27 im: 37 norm: 0.714128946288046
i= 31 im: 41 norm: 0.08318423474708224
i= 33 im: 43 norm: 0.8871081282085561
i= 38 im: 48 norm: 0.0002458165045608516
i= 40 im: 50 norm: 0.6752034911191576
i= 43 im: 53 norm: 0.007145333447324516
</source>
Y por último, para verificar que realmente corresponden a un cero de Riemann, se realiza sobre cada uno de estos valores el proceso ejecutado anteriormente para converger el primer cero
de Riemann, es decir, cuando <math>z_0=0.5+14.135</math>.
Para lograr todos estos cálculos, se entregan las siguientes rutinas.
===Algoritmo use_riem_03===
Cálcula la serie en <math>\hat\zeta</math> tomando como parámetros:
* '''precision''', el número de términos de la sumatoria.
* '''p_real''', el valor para la parte real, normalmente <math>\frac 12</math>, asumiendo que la conjetura de Riemann es correcta.
* '''p_img''', para la parte imaginaria de <math>z</math>.
la función devuelve dos valores de tipo '''float64''' con las partes real e imaginaria de la sumatoria en <math>\hat\zeta</math>.
<source lang=C>
func RiemannSerie(precision int,p_real,
p_img float64)(float64,float64){
// calcula al serie de Riemann
var n,i int
var a,b,ang,sen,cos,pr float64
var fre,fcmp,cmp,re,sumac,sumar float64
var bas,fac float64
n=precision
sumar=0
sumac=0
bas=-1.0
a=p_real
b=p_img
for i=1;i<n;i++{
ang=b*math.Log(float64(i))
sen=math.Sin(ang)
cos=math.Cos(ang)
pr=math.Pow(float64(i),a)
fac=math.Pow(bas,float64(i-1))
fre=fac*(cos/pr)
fcmp=fac*(sen/pr)
re=fre+sumar
cmp=fcmp+sumac
fmt.Printf("i= %d real: %g complex: %g\n",i,re,cmp)
sumar=re
sumac=cmp
}
return re,cmp
}
</source>
===Algoritmo use_riem_04===
Realiza la convergencia sobre un solo dígito, como se explicó anteriormente. Toma los siguientes parámetros:
* '''precision''', el número de términos de la sumatoria.
* '''dec''', un número entero de la forma 10, 100, 1000, 10000, etc., dependiendo de si se trata del primer decimal, segundo, tercero, etc.
* '''p_real''', el valor para la parte real, normalmente <math>\frac 12</math>, asumiendo que la conjetura de Riemann es correcta.
* '''p_img''', para la parte imaginaria de <math>z</math>.
La función devuelve la parte imaginaria de la sumatoria en <math>\hat\zeta</math>.
<source lang=C>
func GetConvergeDig(precision,dec int,p_real,
p_img float64)float64{
// devuelve la parte imaginaria que converge
// con el criterio de la menor norma
var i,dig int
var re,im,norm,p_dec,b,minor float64
p_dec=1/float64(dec)
b=p_img
minor=10000000000000000000.0
for i=0;i<10;i++{
re,im=RiemannSerie(precision,p_real,b)
norm=re*re+im*im
if norm<minor{
minor=norm
dig=i
}
b=b+p_dec
}
im=p_img+float64(dig)*p_dec
return im
}
</source>
===Algoritmo use_riem_05===
Realiza la convergencia sobre todos los dígitos, como se explicó anteriormente. Toma los siguientes parámetros:
* '''precision''', el número de términos de la sumatoria.
* '''p_real''', el valor para la parte real, normalmente <math>\frac 12</math>, asumiendo que la conjetura de Riemann es correcta.
* '''p_img''', para la parte imaginaria de <math>z</math>.
La función devuelve la parte imaginaria de la sumatoria en <math>\hat\zeta</math>, con todos los dígitos que convergen.
<source lang=C>
func ConvergeImgZero(precision int,p_real,
p_img float64)float64{
// devuelve la parte imaginaria del cero que
// converge en la serie
var i,va_dec,Digs int
var b_im,test float64
va_dec=10
Digs=5
for i=0;i<Digs;i++{
b_im=GetConvergeDig(precision,va_dec,p_real,p_img)
fmt.Printf("i= %d b_im: %2.6g\n",i,b_im)
va_dec*=10
p_img=b_im
}
test=b_im-math.Floor(b_im)
if test>=0.999{b_im=0}
return b_im
}
</source>
===Algoritmo use_riem_06===
Realiza una prueba sobre enteros consecutivos para determinar posibles ceros de Riemann. Toma los siguientes parámetros:
* '''precision''', el número de términos de la sumatoria.
* '''iters''', el número de enteros a probar.
* '''p_real''', el valor para la parte real, normalmente <math>\frac 12</math>, asumiendo que la conjetura de Riemann es correcta.
* '''p_img''', para la parte imaginaria de <math>z</math>.
La función no devuelve ningún valor, pero imprime en pantalla el resultado de la prueba, la cual se realiza, en realidad, sobre el cuadrado de la norma y no sobre la norma misma.
<source lang=C>
func TestNormRiemann(precision,iters int,p_real,p_img float64){
// realiza una pruena de la norma
// sobre la parte entera de p_img
var i int
var re,im,norm,b float64
fmt.Println("=========Función TestNormRiemann ===========")
fmt.Println("Realiza una prueba sobre la norma de la serie")
fmt.Printf("Tiempo antes de la prueba: %v \n",time.Now())
b=p_img
for i=0;i<iters;i++{
re,im=RiemannSerie(precision,p_real,b)
norm=re*re+im*im
fmt.Printf("i= %d im: %4.6g norm: %g\n",i,b,norm)
norm=re*re+im*im
b++
}
fmt.Printf("Tiempo despues de la prueba: %v \n",time.Now())
}
</source>
Con estas herramientas se procede a construir el código que automatiza todo el proceso, es decir, una rutina que investiga si un determinado valor puede ser un cero de Riemann y si
encuentra que la respuesta es positiva procede con la convergencia del valor en cuestión. El código para esta rutina es como sigue:
===Algoritmo use_riem_07===
Investiga sobre un intervalo dado la existencia de los ceros de Riemann. Toma los siguientes parámetros:
* '''precision''', el número de términos de la sumatoria.
* '''NumCeros''', el número de ceros de Riemann a calcular.
* '''p_real''', el valor para la parte real, normalmente <math>\frac 12</math>, asumiendo que la conjetura de Riemann es correcta.
* '''p_img''', para la parte imaginaria de <math>z</math>.
La función no devuelve ningún valor, pero imprime en pantalla el resultado del cómputo.
<source lang=C>
func SearchRiemannZeros(precision,NumCeros int,p_real,
p_img float64){
// busca los ceros de Riemann en un determinado intervalo
// que empieza por from y continua hasta agotar iters
var i,ceros int
var re,im,b_im,norm float64
fmt.Println("======Función SearchRiemannZeros ========")
fmt.Println("Busca los ceros de Riemann en un intervalo")
fmt.Printf("Tiempo antes de inciar: %v \n",time.Now())
ceros=0
for i=0; ;i++{
re,im=RiemannSerie(precision,p_real,p_img)
norm=re*re+im*im
if(norm>1){
p_img++
continue
}else{
b_im=ConvergeImgZero(precision,p_real,p_img)
if (norm<0.9){
// es un cero de riemann
if b_im==math.Floor(b_im){
b_im--
b_im=ConvergeImgZero(precision,p_real,b_im)
}
ceros++
fmt.Printf("Iter= %d Cero No %d de %d real: %g img: %g
norma: %g suma real: %g suma img %g\n",i,ceros,
NumCeros,p_real,b_im,norm,re,im)
if(ceros==NumCeros){break}
}
}
p_img++
}
fmt.Printf("Tiempo despues de calcular: %v \n",time.Now())
}
</source>
'''Eureka'''! Se cuenta ahora con un algoritmo para hacer converger los ceros de la función Z de Riemann y para estrenarlo se procede a calcular los primeros 50 ceros de <math>\hat\zeta(s)</math>.
Para este último ejercicio la función '''main()''' usada es como sigue
<source lang=C>
func main() {
var precision int
var p_real,p_img float64
precision=1000000
p_real=0.5
p_img=10.0
SearchRiemannZeros(precision,50,p_real,p_img)
}
</source>
El resultado se muestra a continuación:
<source lang=C>
D:\devgo\projects\riemann>go run riem_cmp.go
=========Función SearchRiemannZeros ===========
Busca los ceros de Riemann en un intervalo dado ...
Tiempo antes de inciar: 2017-05-22 17:51:49.763298 -0500
1 re: 0.5 im: 14.135 norm: 0.06356 sr: 0.01232 si 0.2518
2 re: 0.5 im: 21.02225 norm: 0.002663 sr: 0.02381 si 0.04578
3 re: 0.5 im: 25.011 norm: 0.000614 sr: -0.01467 si 0.01997
4 re: 0.5 im: 32.94 norm: 0.04002 sr: -6.528e-05 si -0.2001
5 re: 0.5 im: 37.6 norm: 0.7141 sr: 0.7206 si -0.4414
6 re: 0.5 im: 40.92 norm: 0.08318 sr: 0.1035 si -0.2692
7 re: 0.5 im: 43.33 norm: 0.8871 sr: 0.02987 si 0.9414
8 re: 0.5 im: 48.01 norm: 0.0002458 sr: -0.001655 si 0.01559
9 re: 0.5 im: 49.8 norm: 0.6752 sr: -0.1496 si -0.808
10 re: 0.5 im: 52.9705 norm: 0.007145 sr: 0.078 si -0.03257
11 re: 0.5 im: 60.832 norm: 0.3139 sr: 0.01959 si -0.5599
12 re: 0.5 im: 65.113 norm: 0.1183 sr: 0.2175 si 0.2665
13 re: 0.5 im: 67.1 norm: 0.1034 sr: 0.1703 si 0.2727
14 re: 0.5 im: 72.1 norm: 0.01362 sr: -0.1155 si -0.01648
15 re: 0.5 im: 77.145 norm: 0.2335 sr: 0.2539 si 0.4111
16 re: 0.5 im: 82.9105 norm: 0.07386 sr: -0.1481 si -0.2278
17 re: 0.5 im: 88.81 norm: 0.391 sr: 0.2994 si -0.549
18 re: 0.5 im: 95.9 norm: 0.3038 sr: -0.2343 si -0.4989
19 re: 0.5 im: 98.83123 norm: 0.1752 sr: 0.3573 si 0.218
20 re: 0.5 im: 107.2 norm: 0.4294 sr: -0.006762 si 0.6552
21 re: 0.5 im: 111.9 norm: 0.006905 sr: -0.03246 si 0.07649
22 re: 0.5 im: 118.8 norm: 0.6578 sr: -0.7262 si -0.3611
23 re: 0.5 im: 122.95 norm: 0.03759 sr: 0.06261 si -0.1835
24 re: 0.5 im: 127.52 norm: 0.8405 sr: -0.005735 si -0.9168
25 re: 0.5 im: 131.1 norm: 0.2224 sr: 0.2834 si 0.377
26 re: 0.5 im: 134.8 norm: 0.4937 sr: 0.6081 si -0.3521
27 re: 0.5 im: 138.12 norm: 0.3847 sr: 0.1441 si 0.6033
28 re: 0.5 im: 141.124 norm: 0.3138 sr: 0.3161 si 0.4625
29 re: 0.5 im: 143.112 norm: 0.4136 sr: -0.153 si 0.6247
30 re: 0.5 im: 146.0011 norm: 0.0000107 sr: 0.002802 si 0.0017
31 re: 0.5 im: 150.93 norm: 0.04704 sr: -0.1763 si 0.1263
32 re: 0.5 im: 153.025 norm: 0.01039 sr: -0.07712 si 0.06668
33 re: 0.5 im: 156.113009 norm: 0.3202 sr: 0.116 si 0.5538
34 re: 0.5 im: 158.85010 norm: 0.6862 sr: -0.3049 si -0.7702
35 re: 0.5 im: 163.031 norm: 0.003003 sr: -0.03573 si -0.04155
36 re: 0.5 im: 169.1 norm: 0.1119 sr: -0.192 si 0.274
37 re: 0.5 im: 179.920 norm: 0.1124 sr: 0.2767 si -0.1894
38 re: 0.5 im: 182.209 norm: 0.5234 sr: 0.5841 si -0.4268
39 re: 0.5 im: 185.6 norm: 0.127 sr: 0.3441 si -0.09269
40 re: 0.5 im: 192.03 norm: 0.0104 sr: 0.02836 si 0.09797
41 re: 0.5 im: 193.1 norm: 0.1232 sr: 0.3311 si 0.1166
42 re: 0.5 im: 198.02 norm: 0.003324 sr: -0.006538 si 0.05728
43 re: 0.5 im: 207.91 norm: 0.05683 sr: 0.1267 si 0.202
44 re: 0.5 im: 216.2 norm: 0.7524 sr: -0.0599 si 0.8653
45 re: 0.5 im: 219.1 norm: 0.1241 sr: 0.1498 si 0.3188
46 re: 0.5 im: 221.431 norm: 0.381 sr: 0.4845 si -0.3824
47 re: 0.5 im: 224.01 norm: 0.001307 sr: -0.03393 si 0.01249
48 re: 0.5 im: 231.3 norm: 0.001885 sr: -0.02378 si -0.03633
49 re: 0.5 im: 241.05 norm: 0.1095 sr: -0.002696 si 0.3309
50 re: 0.5 im: 244.1 norm: 0.04349 sr: -0.1458 si 0.1491
Tiempo despues de calcular: 2017-05-22 18:08:13.9945211 -0500
</source>
donde,
* '''re''' se refiere a la parte real de <math>z_0</math>,
* '''im''' hace lo propio con la parte imaginaria
* '''norm''' es <math>|\hat\zeta(z_0)|</math>
* '''sr''' es la sumatoria sobre la parte real de <math>\hat\zeta(z_0)</math>, es decir, <math>\Re(\hat\zeta(z_0))</math> y
* '''si''' es la sumatoria sobre la parte imaginaria de <math>\hat\zeta(z_0)</math>, esto es, <math>\Im(\zeta(z_0))</math> y <math>z_0</math> es un cero de <math>\hat\zeta(s)</math>, como se definió anteriormente.
Algunos valores han sido recortados un poco par conveniencia, pero en términos aceptables, esta es la salida de la rutina que calcula y converge los valores
de <math>z_0</math> para los primeros 50 ceros de la función Z de Riemann. Observando la salida, se aprecia que el tiempo de convergencia para estos 50 primeros ceros es de apenas 16 minutos!
==Notas==
*[1] En realidad se puede hablar de infinitas rectas, a pesar de no contar con una demostración de tal afirmación, es un hecho que valores como <math>\Re(s)=0.51,0.511,0.5111,</math> etc., también cuentan como rectas!
*[2] Este valor de <math>\Re(s)=0.43</math> para la cota por la izquierda del intervalo de investigación (<math>0<\Re(s)<1</math>), debe entenderse como '''provisional''' hasta tanto alguien encuentre un valor más cercano a cero.
*[3] Los valores decimales en las tablas presentadas, han sido recortados un poco para permitir su formateo en '''Tex''', para conocer estos valores con mayor exactitud se deben consultar los archivos de texto generados por el software durante el cómputo de los ceros, los cuales se pueden descargar desde la sección de '''Enlaces externos'''.
==Referencias==
* 1. Useche, H. (2017), '''Convergencia de la Función Z de Riemann''' - Memorias del X Seminario Internacional de Matemática Aplicada ([[http://ift.tt/2lsADsa PDF]]), Universidad Surcolombiana (USCO), Neiva, Huila, Colombia.
* 2. Useche, H. (2017), '''Convergencia de la Función Z de Riemann'''([[http://ift.tt/2lyBs1R PDF]]), Neiva, Huila, Colombia. 47 p.
* 3. Useche, H. (2017), '''Aclaraciones a la Convergencia de la Función Z de Riemann'''([[http://ift.tt/2lrFSZg PDF]]), Neiva, Huila, Colombia. 20 p.
===Enlaces externos===
*[http://ift.tt/2lxROYx Descargue aquí documentos y software para calcular los ceros de la función zeta de Riemann]
http://ift.tt/2lqhuHy
