Zeta-Funktion

Die Zeta-Funktion nach dem deutschen Mathematiker Bernhard Riemann entstand aus der Problemstellung, die Anzahl der Primzahlen unterhalb einer Schranke n möglichst gut zu schätzen. Die Funktion wird besonders für Eingaben aus den komplexen Zahlen interessant. Man hat festgestellt, dass sehr viele Nullstellen der Funktion auf der Gerade mit dem Realteil(x) = 0.5 liegen. Jede Primzahl entspricht einer Nullstelle der Zetafunktion. Eine einfache Form der Berechnung soll im folgenden gegeben werden.

Historisches ([MdS03], S.115ff)

Die Verteilung der Primzahlen wirkt zufällig ohne Muster, aber C. F. Gauss hatte versucht, die Anzahl Primzahlen bis zu einer Zahl n herzuleiten, genannt Li(n). Der Fehler dieser Funktion wurde asymptotisch gesehen immer größer. Riemann konnte aus den Nullstellen eine exakte Formel für die Anzahl der Primstellen bis zu einer Zahl n herleiten, indem er eine Funktion R(n) entwarf, welche sich schon besser als die Gauss-Funktion Li(n) verhielt, er aber diese Fehler mit den Nullstellen loswerden konnte.
nexakte Anzahl Prims. <= n Fehler R(n)Fehler Li(n)
10^2251 5
10^3168 010
10^85.761.455 97754
10^950.847.534 -791701
Gauss selbst vermutete anfangs die Formel n / log(n), was aber von Legendre auf n / (log(n) - 1.08366) verbessert wurde. Li(n) = ∫2n (1 / log(x)) dx.

Formel zur Berechnung der Zeta-Funktion [JuHa07]

Es gibt eine Formel, um Zeta mit Multiplikation zu ermitteln. Aufgrund numerischer Probleme (bei Multiplikation gehen schneller Rundungsstellen verloren als bei Addition) und der Tatsache, dass man dafür eine Tabelle der Primzahlen braucht, wird diese hier nur wiedergegeben.
Parameter s = a + bi, a, b aus den reellen Zahlen; i ist die imaginäre Einheit, a > 0.0
Hierbei ergibt sich im Spezialfall b = 0 eine reelle Reihe, bei a = 2 z.B. die Kehrbrüche aller Quadrate (1 + 1/4 + 1/9 + 1/16 + 1/25 +1/36 + 1/49 + ... = π*π / 6. Folgende Formeln sind dafür bekannt:
Zeta(2s) = (-1)s-1 * (2π)2s / (2 * (2s)!) * B2s // gerade Eingabe, B steht für Bernouli-Zahl
Zeta(2s+1) = 2 * ∑j=1 j-(2s+1) / (e2*π*j - 1) // ungerade Eingabe
Die reellen Reihen haben zudem ein einfaches Konvergenzverhalten, da die Folgenglieder monoton fallend sind. Auch im reellen Fall konvergiert die Reihe nicht immer zu einem Grenzwert, wie man bei der harmonischen Reihe a=1, b=0 sieht. Es wird im folgenden der allgemeine Fall mit komplexen Eingabewerten vorausgesetzt.
Anm.: Bei der Produktformel nach Euler lassen sich Primzahlen den Nullstellen nicht direkt zuordnen. pks ist nie 0+0i, sondern der Grenzwert für k ist ∞, so dass das Produktglied gegen 1.0 geht.

Vergleich mit Integral

Das Integral wird berechnet: ∫1g (1 / xs) dx = (g-s+1 - 1) / (-s + 1).
speziell s=2: -(g-1 - 1) = 1 - 1/g (Grenzwert 1)
speziell s=0.5: (g0.5 - 1) / 0.5 = 2 * (√(g) - 1) (Grenzwert ∞)
allgemein s=a+bi: ((g-(a+b*i) + 1 - 1) * (1 - a + b * i)) / ((1 - a)2 + b2) ,Grenzwert bei a > 1 ist 1 / ((a + b*i) - 1)
Zumindest im reellen Fall ist das Integral eine Untergrenze für die Zetafunktion, siehe folg. Tabelle.
Art \ g12345
∑ s=211,251,361,421,46Pi*Pi/6
∫ s=200,50,660,750,81,0
Art \ g12345
∑ s=0.511,702,2782,7783,23
∫ s=0.500,821,462,02,47
Man sieht, dass die Berechnung erst für a < 1 schwierig wird. Ein Grenzwert, sogar Nullstellen auf der kritischen imaginären Gerade, existieren aber sehr oft.

Numerische Berechnung

Für die Zeta-Nullstellen ist a=0.5, d.h. der reelle Skalierungsfaktor für jedes Folgenglied ist 1/√(n). Betragsmäßig sind die Sinus- und Cosinus-Terme durch 1.0 beschränkt.
Die alternierende Funktion hat das beste Konvergenzverhalten, mit einer Transformation kann der Wert der Zetafunktion daraus ermittelt werden.
Leibniz-Kritierum
- Nullfolge der Glieder(ist erfüllt für a > 0)
- Glieder sind stets positiv (nicht immer erfüllt wegen cos, sin)
- Glieder sind monoton fallend (auch nicht immer erfüllt)
--> Im allgemeinen Fall (imaginäre Werte) ist das Leibniz-Kriterium für die alterniernde Zetareihe nicht erfüllt.
Programme für die alternierende Reihe
Perl-Programm für die alternierende Reihe
#! /usr/bin/perl -w

# Eingabewerte
$a = 0.5; $b = 25.02;  # 14.14, 21.02, 25.02 Naehe zu Nullstelle
$eps = 0.0001;

# Rechnung
sub zetaAlt
{
  my $a = $_[0]; my $b = $_[1];
  if ($a <= 0.0) { die "Zetafunktion nur für positive Realwerte berechenbar\n"; }
  $real = 1.0; $imag = 0.0; $faktorAlt = 1e9; $realSummeAlt = 0.0; $imagSummeAlt = 0.0;
  for($n=2; $n < 1e6; ++$n)
  {
    $loga = log($n); 
    $faktor = ($a == 0.5 ? 1.0/sqrt($n) : ($a == 1.0 ? 1.0/$n : exp(-$a * $loga)));
    $wert = $b * $loga;
    $zusatzReal = cos($wert) * $faktor; if (($n & 1) == 0) { $zusatzReal = - $zusatzReal; }
    $real += $zusatzReal;
    $zusatzImag = sin($wert) * $faktor; if (($n & 1) == 0) { $zusatzImag = - $zusatzImag; }
    $imag -= $zusatzImag;
    if (($n & 1 == 0) && ($faktorAlt - $faktor < $eps)) {
      print "Abbruch nach $n Iterationen\n"; last;
    }
    $faktorAlt = $faktor; $realSummeAlt = $real; $imagSummeAlt = $imag;
  }
  # Extrapolation
  $real = ((1 + $a) * $real + $realSummeAlt) / (2 + $a);  # neueren Wert stärker
  $imag = ((1 + $a) * $imag + $imagSummeAlt) / (2 + $a);
  print($real." + i * ".$imag."\n");
}

&zetaAlt($a, $b);
Python-Programm für die alternierende Reihe
#! /usr/bin/python3.4
# Berechnet die alternierende Zetafunktion, auch für komplexe Werte
import math

eps = 0.0001

# gibt alternierende Zeta-Funktion als komplexen Wert zurück
def zetaAlt(eingabe):
  if (eingabe.real < eps): raise RuntimeError("Zetafunktion nur für positive Realwerte berechenbar")
  summe = 1.0 + 0.0j
  summeAlt = 0.0 + 0.0j
  faktorAlt = 1e9
  for n in range(2,100000):
    loga = math.log(n)
    if eingabe.real == 0.5:
      faktor = 1.0 / (math.sqrt(n))
    elif eingabe.real == 1.0:
      faktor = 1.0 / n
    else:
      faktor = math.exp(-eingabe.real * loga)
    teil = loga * eingabe.imag
    zusatz = complex(faktor * math.cos(teil), - faktor * math.sin(teil))
    if ((n & 1) == 0): zusatz = -zusatz  # hier alternierend
    summe = summe + zusatz
    if ((n & 1 == 0) and (faktorAlt - faktor < eps)): 
      print("Abbruch nach Iterationen: " + str(n))
      break
    faktorAlt = faktor
    summeAlt = summe
  return ((1.0 + eingabe.real) * summe + summeAlt) / (2.0 + eingabe.real)  # neueren Wert stärker

# gibt um 90 Grad gedrehte alterniernde Zetafunktion zurück (kritische Gerade liegt auf x-Achse; y max 0.5 !)
def zetaAlt2(eingabe):
  eingabe2 = complex(0.5 - eingabe.imag, eingabe.real)
  return zetaAlt(eingabe2)

print(zetaAlt(2.0))
print(zetaAlt(1.0))  # log(2)
print(zetaAlt(0.5 + 14.14j))  # Nullstelle 1
print(zetaAlt(0.5 + 21.02j))  # Nullstelle 2

print(zetaAlt2(14.14 + 0j))  # Nullstelle 1
Anzeige mit matplotlib
import matplotlib.pyplot as plt
import numpy as np

# Definition von zetaAlt siehe oben

keys = []
werte = []
for b in range(1300,2200,5):
  rueck = zetaAlt(complex(0.5, b/100.0))
  keys.append(b/100.0)
  werte.append(rueck.real * rueck.real + rueck.imag * rueck.imag)
t = np.array(keys)
y = np.array(werte)
plt.plot(t,y, linewidth=2)
plt.xlabel('Imaginärteil')
plt.ylabel('Betrag Zeta')
plt.grid(True)
plt.show()
Matplotlib-Diagramm
Transformation Alternierende Reihe
Zeta_alt(s) + 2 * 2-s * Zeta(s) = Zeta(s)
Zeta(s) * (1 - 2-s + 1) = Zeta_alt(s)
Zeta(s) = Zeta_alt(s) / (1 - 2-s + 1)
--> Eine Nullstelle der alt. Reihe ist damit auch Nullstelle der Zetafunktion. Fuer s = 1 + 0i hat die Zetafunktion eine Polstelle, die alternierende Funktion aber den Wert log(2) = 0.693, während bei der Umrechnung durch 0 geteilt werden würde. Die Reihe läuft bis ins Unendliche (∞), die Summation stoppt aber vorher, am besten mit einem konvergierenden Fixpunktwert. Aber es bleibt immer ein Restwert zurück.
Diagramm Konvergrenzverhalten/Funktionswerte (HTML5-Canvas) ([MdS03],S.100ff)
Achtung: Es wird nur die alternierende Zeta-Summe betrachtet, und der obige numerisch einfache Algorithmus genutzt. Bei Verkleinerung der Genauigkeit oder Erhöhung der Iterationen wird die Darstellung genauer, aber der Rechenaufwand steigt.

Nullstellengebiete Im Folgenden werden Funktionswerte eingefärbt.
Die Einfärbung der Gebiete erfolgt anhand der beiden Vorzeichen der Funktionswerte
Farben: Rot (real und imag < 0), grün (real < 0, imag > 0), blau (real > 0, imag < 0), rosa (real > 0 und imag > 0). In Schwarz wird ggf. die Riemann-Gerade an Realteil 0.5 in schwarz eingezeichnet.
Achtung: Kommaangaben hier mit Punkt(.) !
Minimaler Realteil(links):
Maximaler Realteil(rechts):
Minimaler Imaginärteil(unten):
Maximaler Imaginärteil(oben):
Genauigkeit:
maximale Iterationen Funktion: *


Platzhalter: Hier wird das Diagramm zu den Funktionswerten angezeigt ...


Automatische Suche entlang der Gerade bei a=0.5 Im angegebenen Imaginärbereich wird iterativ gesucht. Damit können auch Nullstellen gefunden werden, deren Imaginärbereich ausserhalb liegt.
Achtung: Kommaangaben hier mit Punkt(.) !
Erster Imaginärteil:
Letzter Imaginärteil:
Suchschritt:
maximale Iterationen Funktion: *
maximale Iterationen Suche:
Genauigkeit:
Fortschritt:


Platzhalter: Hier werden Meldungen zur Nullstellensuche angezeigt ...


Höhenlinien Pro Pixel wird der Betrag des Funktionswertes berechnet und durch Teilung mit der Stufe einem Höhenniveau zugeordnet. Wird die Stufe geeignet gewählt, liegen gleiche Betragsniveaus der Funktionswerte im gleichen Farbbereich.
Achtung: Kommaangaben hier mit Punkt(.) !
Minimaler Realteil(links):
Maximaler Realteil(rechts):
Minimaler Imaginärteil(unten):
Maximaler Imaginärteil(oben):
Genauigkeit:
maximale Iterationen Funktion: *
Höhenstufe:


Platzhalter: Hier wird das Diagramm zu den Höhenlinien angezeigt ...

Klassifikation von Nullstellen
Nach visueller Ansicht der alternierenden Zetafunktion sieht man nach links öffnende Parabeln, welche von gebogenen Linien gekreuzt werden. Hier gibt es drei Hauptmöglichkeiten ( Schnitt 1=unterer Ast, 2=Scheitel, 3=oberer Ast). Beim Schnitt zweier Parabeln wird diejenige genommen, deren Scheitel naeher an der kritischen Gerade liegt.
zeta_nullstelle2 zeta_nullstelle1 zeta_nullstelle3
Weitere Forschungen und Aspekte zur Riemannschen Zetafunktion
Mit dem Einsetzen von Computern konnte man immer mehr Nullstellen berechnen und nachweisen, dass sie auf der kritischen Gerade liegen.
Quellen (gelesener und empfehlenswerter Bücher)
KürzelAutor TitelVerlag
[MdS03]Marcus du SautoyDie Musik der Primzahlen dtv-Verlag 2003
[JuHa07]Julian Havil GammaSpringer Verlag 2007