Mathematik on kenji.blog

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

Sat, 05 Sep 2026 13:04:59 +0900

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

Die “RSA-Verschlüsselung”, die das heutige Internet grundlegend stützt. Ihre Robustheit beruht auf der mathematischen Überzeugung, dass “es für heutige Computer praktisch unmöglich ist, gigantische zusammengesetzte Zahlen in Primfaktoren zu zerlegen”.

Aber die Menschheit hat nie aufgegeben. Gegenwärtig gibt es für klassische Computer (normale Computer, keine Quantencomputer) den ** stärksten und fortschrittlichsten Algorithmus der Menschheit ** zur Durchführung riesiger Primfaktorzerlegungen. Das ist das ** “General Number Field Sieve (GNFS, Allgemeines Zahlkörpersieb)” **.

In diesem Artikel werden wir den gesamten Quellcode einer streng modellierten Implementierung der hochmodernen Berechnungslogik von GNFS in C++ (unter Verwendung von boost::multiprecision für Multipräzisions-Ganzzahlen aus der Boost-Bibliothek) veröffentlichen und die Tiefen der “algebraischen Zahlentheorie”, die dahinter steckt, gründlich erklären.

Bitte genießen Sie das Mysterium der Mathematik und die rohe Kraft der Informatik, die es bezwingt, zusammen mit dem Quellcode.

1. GNFS State-of-the-Art Logik-Framework (Gesamter Quellcode)

Zunächst zeigen wir das vollständige Bild der GNFS-C++-Implementierung, die wir diesmal erläutern. Das eigentliche Zahlkörpersieb (wie CADO-NFS) ist ein riesiges verteiltes System, das in die Hunderttausende von Zeilen geht, aber dieser Code extrahiert die ** “5 wesentlichen Pipelines (Phasen)” ** , die GNFS ausmachen, entwirft sie als Klassen und modelliert sie in einer Minimalkonfiguration, ohne die mathematische Bedeutung zu verlieren.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Multipräzisions-Ganzzahlen von Boost.Multiprecision verwenden
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (Allgemeines Zahlkörpersieb) State-of-the-Art Logik-Framework
//
// Dieser Code ist eine strikte Modellierung der 5 Pipelines des hochmodernen GNFS,
// wie es in CADO-NFS usw. verwendet wird, als C++ (Boost) Klassendesign.
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung Algorithmus)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polynom der algebraischen Seite f(x)
 std::vector<cpp_int> g; // Polynom der rationalen Seite g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Generierung des Initialpolynoms basierend auf der base-m Entwicklung (tatsächlich wird eine fortgeschrittenere Gitterbasisreduktion LLL verwendet)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // Einfache base-m Entwicklung (Grad d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Einfache Näherung für m (Näherung ohne Verwendung von Boost-Funktionen)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (Gittersieb)
// ============================================================================
// Aktuelle GNFS verwenden anstelle des Line Sieve (Liniensieb) das Special-q Lattice Sieving
// (Spezielles q-Gittersieb) von Franke, Kleinjung et al. als De-facto-Standard.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (Ausgelassen) In Wirklichkeit werden Primzahlen generiert und mit Legendre-Symbolen etc. gefiltert
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // Mock-Implementierung: Das tatsächliche Gittersieb scannt blockweise Hunderte von GB an Speicherraum,
 // ordnet (a, b) Paare Gittern pro spezieller Primzahl q (a = i*q + j*...) zu
 // und führt ein Sieben mit maximaler Cache-Effizienz aus.

 // Füge zu Demonstrationszwecken eine Dummy-Relation hinzu
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (Singularitäten bereinigen und Cliquen zusammenführen)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (Löschen von Relationen mit Primzahlen, die nur einmal vorkommen)
 // 2. Clique merging (Zusammenführen von Relationen, um spärliche Matrizen dicht zu machen)
 // In der Praxis werden hunderte Millionen von Zeilen mit Union-Find-Algorithmen usw. auf einige Millionen komprimiert.
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann Methode)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // In neueren Supercomputer-Umgebungen wird die für verteiltes Rechnen besser geeignete
 // Block Wiedemann Methode (Coppersmith-Implementierung) anstelle der Block Lanczos Methode als State-of-the-Art eingesetzt.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // Iteriert das Produkt von spärlichen Matrizen (Sparse Matrix) und Vektoren,
 // und findet mehrere Lösungsvektoren (Kerne), für die M * x = 0 mod 2 gilt.

 std::vector<std::vector<int>> dependencies; // Liste der Abhängigkeiten
 // Dummy-Daten
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root (Algebraische Quadratwurzel)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. Berechnung der Quadratwurzel V der rationalen Seite (einfache Ganzzahlarithmetik)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Berechnung der Quadratwurzel gamma der algebraischen Seite (Montgomery's Methode etc.)
 // Findet das Element gamma des riesigen algebraischen Körpers O_K und bildet es mit dem Homomorphismus phi auf die reale Welt ab
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Es wird vorausgesetzt, dass in Phase 2 und 4 Folgen von quadratischen Resten (Quadratic Characters) hinzugefügt wurden,
 // um die Hindernisse (Obstructions) der Idealklassengruppe und der Einheitengruppe zu umgehen.

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Die gigantische zusammengesetzte Zahl N, die wir in Primfaktoren zerlegen wollen, z. B. RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Der Grad des Polynoms (bei mehr als 130 Stellen wird normalerweise Grad 5 bis 6 gewählt)
 int degree = 6;

 // Initialisierung der Pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Tatsächliche Schranken (Bounds) liegen bei Dutzenden bis Hunderten von Millionen
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Polynom-Selektion
 poly_select.select(N);

 // 2. Sieb-Verarbeitung (Sieving)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filterung (Matrixkompression)
 filter.reduce_matrix(relations);

 // 4. Lineare Algebra (Nullraum-Suche über GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Berechnung der algebraischen Quadratwurzel und GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

Nun, wie durchbricht dieser Code die kryptographischen Mauern? Wir werden für jede der 5 Phasen die detaillierten Algorithmen und die fortgeschrittene Mathematik verdaulich erklären.

2. Das ultimative Ziel von GNFS: $X^2 \equiv Y^2 \pmod N$

Das Ziel von GNFS, wie auch den meisten modernen Algorithmen zur gigantischen Primfaktorzerlegung, ist es, ein nicht-triviales Paar $(X, Y)$ zu finden, das die folgende Kongruenz erfüllt:

$$X^2 \equiv Y^2 \pmod N$$

Diese Gleichung bedeutet, dass “die Reste von $X^2$ und $Y^2$, wenn man sie durch $N$ teilt, gleich sind”. Umgeformt ergibt das: $X^2 - Y^2 \equiv 0 \pmod N$ Das heißt, $(X-Y)(X+Y)$ ist ein Vielfaches von $N$.

Wenn $X \not\equiv \pm Y \pmod N$ (eine nicht-triviale Lösung) gilt, gibt es zwischen $(X-Y)$ und $N$ einen “gemeinsamen Teiler größer als 1 und kleiner als $N$”. Wenn wir hier den Euklidischen Algorithmus anwenden, um ** $\gcd(X-Y, N)$ ** zu berechnen, finden wir die Primfaktoren von $N$ sehr leicht.

Jedoch ist die Suche nach diesen $X$ und $Y$ wie die Suche nach der Nadel im Heuhaufen. Daher wählt GNFS den genialen Ansatz, ** “zwei Welten” ** zu erschaffen – die “Welt der realen ganzen Zahlen” und die “Welt der algebraischen Zahlkörper von Polynomen” – und die Berechnungen aufzuteilen.

3. Phase 1: Polynom-Selektion (Polynomial Selection)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Berechnung von m = N^(1/d) und base-m Entwicklung
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

Der erste Schritt von GNFS ist die Schaffung eines “magischen Polynoms”, um die beiden Welten zu überbrücken. Für eine riesige Zahl $N$ wählen wir eine ganze Zahl $m$. Normalerweise wählt man $m \approx N^{1/d}$ (im Code wird ein Polynom $d=6$. Grades angenommen).

Dann entwickeln wir $N$ im $m$-adischen System (Basis $m$) und verwenden die Koeffizienten, um das Polynom $f(x)$ zu konstruieren.

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

Dieses Polynom $f(x)$ hat eine äußerst wichtige Eigenschaft: ** “Wenn man $m$ für die Variable $x$ einsetzt, ergibt es genau $N$ ($f(m) = N$)” **. Mit anderen Worten, $f(m) \equiv 0 \pmod N$. Das Polynom der rationalen Seite ist definiert als $g(x) = x - m$.

Dadurch werden die ** “Welt des algebraischen Zahlkörpers $\mathbb{Z}[\alpha]$” **, die durch die Wurzel $\alpha$ von $f(x)=0$ beherrscht wird, und die gewöhnliche ** “Welt der rationalen Zahlen (ganzen Zahlen) $\mathbb{Z}$” ** durch einen Ringhomomorphismus $x \to m$ fest miteinander verbunden.

In hochmodernen Implementierungen wie CADO-NFS werden Algorithmen wie der KleinJung-Algorithmus oder die LLL-Gitterbasisreduktion verwendet, um monatelang nach dem “absolut besten Polynom $f(x)$” zu suchen, bei dem die Koeffizienten nicht extrem groß werden und in nachfolgenden Schritten leicht Primzahlen auftreten (Smoothness/Glattigkeit begünstigt wird).

4. Phase 2: Spezielles $q$-Gittersieb (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Ordnet (a, b) Paare Gittern pro spezieller Primzahl q zu
 // und führt ein Sieben mit maximaler Cache-Effizienz aus.
 // ...
 }
};

Nachdem die beiden Welten vorbereitet sind, betreten wir den nächsten Schritt: die Suche nach “glatten Zahlen” (Zahlen, die nur aus kleinen Primfaktoren bestehen) in beiden Welten. Wir generieren unzählige ganzzahlige Paare $(a, b)$ und berechnen die folgenden zwei Werte:

** Wert auf der rationalen Seite ** : $a - bm$
** Norm auf der algebraischen Seite ** : $b^d f(a/b)$

Das Ziel von GNFS ist es, zig bis hunderte Millionen ** “Paare (Relationen), bei denen die Werte sowohl der rationalen als auch der algebraischen Seite vollständig in kleine Primfaktoren zerlegt werden können” **, zu sammeln.

In frühen GNFS-Versionen wurde das “Liniensieb (Line Sieve)” verwendet, bei dem die $(a, b)$ auf der $xy$-Ebene aufgereiht und der Reihe nach durch Primzahlen geteilt wurden. Da dies jedoch auf den Speicher überall verstreut zugriff, traten häufig Cache-Misses auf, was es sehr langsam machte.

Deshalb verwenden moderne High-End-Codes die Methode des ** “Speziellen $q$-Gittersiebs (Special-q Lattice Sieve)” **. Man fixiert eine relativ große Primzahl $q$ und berücksichtigt nur Paare $(a, b)$, für die “der algebraische Wert definitiv durch $q$ teilbar ist”. Da die Paare $(a, b)$, die diese Bedingung erfüllen, ein “Gitter (Lattice)” auf der Ebene bilden, ist die Sprungweite der Speicheradressen bei der Berechnung konstant, was perfekt in die L1/L2-Caches der CPUs passt. Die Einführung dieses Gittersiebs hat die Rechengeschwindigkeit von GNFS dramatisch erhöht.

5. Phase 3: Filterung (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (Löschen von Relationen mit Primzahlen, die nur einmal vorkommen)
 // 2. Clique merging (Zusammenführen von Relationen, um spärliche Matrizen dicht zu machen)
 }
};

Computer weltweit haben in Phase 2 über Monate hinweg Hunderte Millionen von Relationen gesammelt. Wenn wir diese jedoch direkt in den nächsten “Schritt zum Lösen von Gleichungssystemen (Matrixberechnung)” werfen, würde selbst der Speicher eines Supercomputers überlaufen.

Daher wird ein extrem starker Matrixkompressionsprozess namens ** Filtering (Filterung) ** durchgeführt.

** Singleton removal (Singularitäten bereinigen) ** Angenommen, eine riesige Primzahl $p$ tritt in Hunderten Millionen Relationen “nur ein einziges Mal” auf. Da es unser Ziel ist, “die Exponenten aller Primzahlen gerade (ein Vielfaches von 2) zu machen”, kann eine Primzahl, die nur einmal auftritt, niemals einen geraden Exponenten erreichen. Daher werden Relationen, die diese Primzahl enthalten, sofort als “nutzloser Müll” gelöscht (bereinigt). Da dies kettenreaktionsartig passiert, werden die Hunderte Millionen Datenzeilen rasant reduziert.
** Clique merging (Cliquen zusammenführen) ** Darüber hinaus werden durch die Kombination (Addition) von Relationen, die bestimmte Primzahlen teilen, die Anzahl der Zeilen reduziert und die spärliche (luftige) Matrix dichter gemacht (es wird ein Ansatz ähnlich der Cliquensuche in der Graphentheorie verwendet).

Durch diese Optimierung wird die gigantische dünnbesetzte Matrix auf eine rechenbare Größe dramatisch komprimiert.

6. Phase 4: Lineare Algebra über GF(2) (Block Wiedemann Methode)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Iteriert das Produkt von spärlichen Matrizen (Sparse Matrix) und Vektoren,
 // und findet mehrere Lösungsvektoren (Kerne), für die M * x = 0 mod 2 gilt.
 }
};

Endlich der Kern des Puzzles. Wir multiplizieren die gesammelten Relationen miteinander, um nach einer ** “Kombination zu suchen, bei der die Exponenten aller Primfaktoren gerade Zahlen werden” **.

Mathematisch gesehen geht es darum, eine riesige Matrix $M$, deren Elemente die Exponenten der Primzahlen (“gerade oder ungerade”, also 0 oder 1) sind, und einen Vektor $x$, der angibt, welche Relationen verwendet werden, zu verwenden, um Lösungsvektoren $x$ (Nullraum / Kern) zu finden, für die gilt: ** $M \cdot x \equiv 0 \pmod 2$ **

Wir müssen ein Gleichungssystem mit einer Matrix von enormer Größe, Millionen von Zeilen × Millionen von Spalten, lösen. Mit der üblichen Gaußschen Elimination wäre die Komplexität $O(N^3)$ und die Berechnung würde nicht enden, bevor das Universum sein Ende findet.

Daher wird in hochmodernen Implementierungen die ** “Block Wiedemann Methode” ** verwendet. Dies ist eine Art Krylov-Unterraum-Methode, die die Tatsache nutzt, dass die Matrix $M$ “sehr spärlich (meistens 0)” ist, und durch wiederholte Multiplikationen von Matrix und Vektoren eine Lösung ableitet. Im Gegensatz zur älteren Block-Lanczos-Methode kann die Block-Wiedemann-Methode den Berechnungsprozess vollständig auf mehrere Cluster aufteilen, wodurch sie bei parallelen Berechnungen im modernen verteilten Cloud-Computing oder auf Supercomputern eine überwältigende Leistung erbringt.

7. Phase 5: Algebraische Quadratwurzel (Algebraic Square Root) und der Zusammenbruch der Kryptographie

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Berechnung der Quadratwurzel V der rationalen Seite
 cpp_int V = 1;

 // 2. Berechnung der Quadratwurzel gamma der algebraischen Seite
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Durch die Matrixberechnung in Phase 4 haben wir “eine Menge von Relationen $S$, die, miteinander multipliziert, für alle Primfaktoren gerade Exponenten ergeben”, erhalten. Damit können wir in beiden Welten, der rationalen und der algebraischen, ein “Quadrat” konstruieren.

Auf der rationalen Seite ist es nur eine Multiplikation von ganzen Zahlen, daher ist die Berechnung der Quadratwurzel $V$ einfach.

$$V^2 = \prod_{S} (a - bm)$$

** Aber die wahre Hölle liegt auf der “algebraischen Seite”. ** In der Welt des algebraischen Zahlkörpers $\mathbb{Z}[\alpha]$ gilt die Eindeutigkeit der Primfaktorzerlegung nicht, weshalb wir Ideale für die Berechnung verwendet haben. Die Matrixberechnung hat nur garantiert, dass es ** “das Quadrat eines Ideals” ** wird, aber ** nicht, dass es “das Quadrat eines Elements ($\gamma^2$)” wird **.

Hier stellen sich uns immense Hürden aus der algebraischen Zahlentheorie in den Weg: das “Hindernis der Idealklassengruppe” und das “Hindernis der Einheitengruppe”. Um diese Hürden zu überwinden, nutzt GNFS die Magie der ** “Quadratischen Reste (Quadratic Characters)” **. Man fügt der Matrix aus Phase 4 vorab heimlich Spalten mit quadratischen Resten (Legendre-Symbolen) für einige Dutzend spezielle Primideale hinzu. Dadurch überspringt die gefundene Menge $S$ mit überwältigender Wahrscheinlichkeit die Hindernisse und bildet erfolgreich das “Quadrat eines echten Elements $\gamma^2$”.

Der Prozess zur Ermittlung von $\gamma$ (die algebraische Quadratwurzel) verwendet hochkomplexe Algorithmen wie die Montgomery-Methode.

Und schließlich wird die algebraische Quadratwurzel $\gamma$ durch den Ringhomomorphismus $\phi$ in die reale Welt teleportiert ($m$ für $x$ einsetzen), um $Y$ zu erhalten. Wenn wir das rationale $V$ einfach $X$ nennen, ist die ultimative Gleichung endlich komplett.

$$X^2 \equiv Y^2 \pmod N$$

Jetzt müssen wir nur noch $\gcd(X-Y, N)$ berechnen. Sobald dieser 0,001-Sekunden-Prozess durchläuft und die nicht-trivialen Faktoren auf dem Bildschirm gedruckt werden, bricht die so unbezwingbar scheinende RSA-Verschlüsselung vollständig zusammen.

Fazit

GNFS ist nicht nur eine Programmiertechnik. Es ist die Kristallisation der menschlichen Intelligenz, die den “Abgrund der reinen Mathematik” wie abstrakte Algebra, Ringtheorie und Idealklassengruppen mit der “extremen Ingenieurskunst” wie der verteilten Architektur von Supercomputern und der Cache-Optimierung bezwungen hat.

Die Chats oder Kreditkarteninformationen, die wir jeden Tag beiläufig senden, werden durch einen solchen astronomischen mathematischen Schlagabtausch geschützt.

Ich hoffe, Sie konnten durch dieses C++-Framework die “Romantik von Mathematik und Computern”, die hinter modernsten kryptoanalytischen Algorithmen steckt, spüren.

Die wahre mathematische Struktur des allgemeinen Zahlkörpersiebs (GNFS)

Sat, 05 Sep 2026 02:26:13 +0900

Die wahre mathematische Struktur des allgemeinen Zahlkörpersiebs (GNFS)

Das ultimative Ziel des GNFS ist es, $X, Y$ so zu finden, dass $X^2 \equiv Y^2 \pmod N$ gilt. Um dies zu erreichen, bauten Mathematiker eine Brücke zwischen der “Welt der reellen ganzen Zahlen” und der “Welt der algebraischen Zahlkörper” . Diese Brücke ist der sogenannte “Homomorphismus”.

Phase 1: Die Welten mit “Homomorphismus” verbinden

1. Auswahl des Polynoms und Definition der Wurzeln

Für eine riesige zusammengesetzte Zahl $N$ wählen wir eine ganze Zahl $m$ und ein Polynom $f(x)$ so, dass $f(m) \equiv 0 \pmod N$ gilt. (Beispiel: Wir entwickeln $N$ zur Basis $m$ und bilden $f(x)$ aus den Koeffizienten. Dabei nehmen wir an, dass $f(x)$ über dem Körper der rationalen Zahlen $\mathbb{Q}$ irreduzibel ist (nicht weiter faktorisiert werden kann)).

Als Nächstes definieren wir eine der “komplexen Wurzeln” der Gleichung $f(x) = 0$ als $\alpha$. Natürlich ist $f(\alpha) = 0$. $\alpha$ ist keine ganze Zahl, sondern eine komplexe Zahl, die Wurzeln und imaginäre Zahlen enthält (eine algebraische Zahl).

2. Konstruktion von Ringen und Homomorphismus

Hier bereiten wir zwei mathematische “Ringe” vor (Welten, in denen Addition und Multiplikation definiert sind).

Welt A: $\mathbb{Z}[\alpha]$ (Der Ring der algebraischen ganzen Zahlen, der $\alpha$ enthält) Eine Zahlenwelt in der Form $a + b\alpha + c\alpha^2 + \dots$.
Welt B: $\mathbb{Z}/N\mathbb{Z}$ (Der Ring der Reste modulo $N$) Eine Kongruenzwelt (Modulo), die nur aus den ganzen Zahlen von $0$ bis $N-1$ besteht.

Hier definieren wir eine Abbildung $\phi$ von Welt A nach Welt B wie folgt: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Diese Abbildung $\phi$ ist eine magische Operation, die exakt die Variable $\alpha$ in Welt A durch die ganze Zahl $m$ in Welt B ersetzt. Dieses $\phi$ besitzt eine extrem mächtige Eigenschaft, die “Ringhomomorphismus” genannt wird. Homomorphismus ist die Eigenschaft, “in eine andere Welt zu teleportieren, ohne die Struktur von Addition und Multiplikation zu zerstören” . Das heißt, die folgenden Gleichungen sind gültig:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

Was bedeutet das? Wenn wir das “Quadrat ($\gamma^2$)” eines komplexen Elements $\gamma$ in “Welt A (der Welt von $\alpha$)” erzeugen und es mithilfe von $\phi$ nach “Welt B (der Restewelt)” teleportieren können, bleibt die quadratische Form $\phi(\gamma)^2$ perfekt erhalten .

Phase 2: Der Zusammenbruch der Primfaktorzerlegung und die Geburt der “Ideale”

In Welt A ($\mathbb{Z}[\alpha]$) wollen wir viele geeignete Elemente $(a - b\alpha)$ sammeln und sie multiplizieren, um ein “perfektes Quadrat (Quadratelement)” zu erzeugen. Normalerweise würden wir jedes gesammelte $(a - b\alpha)$ in Primfaktoren zerlegen und sie so kombinieren, dass die Exponenten der Primzahlen alle gerade sind (durch Lösen mit Matrizen), um ein Quadrat zu bilden.

Jedoch stellt sich hier die verzweifelte Mauer der Algebra in den Weg. In algebraischen Welten wie $\mathbb{Z}[\alpha]$ bricht die “Eindeutigkeit der Primfaktorzerlegung (jede Zahl kann eindeutig als Produkt von Primzahlen ausgedrückt werden)”, die in der Schule gelehrt wird, zusammen .

(Beispiel: In einer bestimmten algebraischen Welt ist $6 = 2 \times 3$, aber gleichzeitig auch $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, und wir wissen nicht mehr, welche die wahren Primzahlen sind)

Wenn die Faktorzerlegung nicht eindeutig ist, ist das Rätsel “Primzahlen zählen, um sie gerade zu machen” (die Siebmethode) im Prinzip unmöglich auszuführen.

Die Rettung durch Kummer und Dedekind: “Ideale”

Was diesen Zusammenbruch rettete, war das Konzept des “Ideals (Ideal: ideale Zahl)” , das von Mathematikern des 19. Jahrhunderts geschaffen wurde. Indem man nicht an das Element selbst dachte, sondern an die “Menge der Vielfachen (Ideal)”, die von diesem Element erzeugt wird, wurde die Primfaktorzerlegung wieder möglich.

Im Ganzheitsring eines algebraischen Zahlkörpers $\mathcal{O}_K$ (ein vollständigerer Ring, der $\mathbb{Z}[\alpha]$ enthält) ist bewiesen, dass selbst wenn ein Element nicht eindeutig faktorisiert werden kann, “ein Ideal immer eindeutig als Produkt von ‘Primidealen ($\mathfrak{p}$)’ faktorisiert werden kann” .

Daher faktorisieren wir im GNFS nicht das Element $(a - b\alpha)$ selbst, sondern das von ihm erzeugte Hauptideal $\langle a - b\alpha \rangle$ in Primideale .

Phase 3: Die Norm und die zwei Siebe

Woher wissen wir also, in welche Primideale das Ideal $\langle a - b\alpha \rangle$ zerfällt? Hier verwenden wir eine Funktion namens “Norm” . Die Norm ist eine Funktion, die komplexe Elemente algebraischer Körper in “normale reelle ganze Zahlen $\mathbb{Z}$” umwandelt.

Die Norm des Elements $(a - b\alpha)$ wird durch eine einfache Polynomrechnung $b^d f(a/b)$ gefunden ($d$ ist der Grad von $f(x)$).

Durch einen algebraischen Satz wissen wir: “Wenn die Norm eines bestimmten Ideals vollständig in kleine Primzahlen zerlegt werden kann (glatt ist), dann kann das ursprüngliche Ideal auch vollständig in kleine Primideale zerlegt werden” .

Daher berechnet GNFS für eine große Anzahl von Ganzzahlpaaren $(a, b)$ gleichzeitig die folgenden zwei Werte und sammelt nur die Paare, bei denen beide zu “glatten Zahlen (smooth numbers)” werden:

Rationales Sieb (Rational Sieve) : $a - bm$ (der Wert in der realen Welt)
Algebraisches Sieb (Algebraic Sieve) : $b^d f(a/b)$ (die Norm in der algebraischen Welt)

Indem wir zig Millionen Paare $(a, b)$ sammeln, bei denen beide glatt sind, lösen wir die Daten der Primidealzerlegung (wie viele Primideale enthalten sind) als riesige Matrix (lineare Algebra über GF(2)), um eine Menge $S$ von Paaren zu finden, sodass “beim Multiplizieren die Exponenten aller Primideale gerade werden”.

Phase 4: Die zwei “Hindernisse” und die Idealklassengruppe

Aus der Matrixberechnung haben wir herausgefunden, dass das Multiplizieren aller Ideale von $(a - b\alpha)$, die zur Menge $S$ gehören, zum Quadrat eines bestimmten Ideals $I$ führt.

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

Es ist jedoch noch nicht vorbei. Die tiefste und schwierigste mathematische Mauer des GNFS befindet sich hier.

Was wir am Ende wollen, ist nicht das “Quadrat eines Ideals”, sondern das “Quadrat eines Elements ($\gamma^2$)” , das wir in die Abbildung $\phi$ einsetzen können. Nur weil es zum Quadrat eines Ideals wurde, heißt das nicht zwangsläufig, dass das Element selbst ein Quadrat ist. Hier gibt es zwei starke mathematische Hindernisse (Obstructions) .

Hindernis ①: Die Barriere der Idealklassengruppe (Ideal Class Group)

Das Ideal $I$ ist nicht immer ein “Ideal, das von einem einzigen Element erzeugt wird (Hauptideal)”. Es ist unmöglich, ein spezifisches Element $\gamma$ aus einem Ideal zu extrahieren, das kein Hauptideal ist.

Hier kommt das Konzept der “Idealklassengruppe (Class Group, $Cl_K$)” ins Spiel. Die Idealklassengruppe ist eine Gruppe, die misst, “wie viele Ideale in dieser algebraischen Welt existieren, die keine Hauptideale sind (wie sehr die Eindeutigkeit der Primfaktorzerlegung gebrochen ist)”. Selbst wenn $\prod \langle a - b\alpha \rangle$ zu $I^2$ wird, kann es nicht auf das Quadrat eines Elements zurückgeführt werden, wenn $I$ nicht das Identitätselement (Hauptideal) in der Idealklassengruppe ist.

Hindernis ②: Die Barriere der Einheitengruppe (Unit Group)

Angenommen, durch Glück wäre $I$ das Hauptideal $\langle \gamma \rangle$. Dann hätten wir $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Man könnte denken: “Großartig, das Element ist auch ein Quadrat!”, aber das ist ein großer Irrtum.

Dass Ideale (Mengen von Vielfachen) gleich sind, bedeutet nicht, dass die Elemente perfekt gleich sind. Es wird immer eine Abweichung durch eine “Einheit (Unit: eine Zahl, deren Kehrwert ebenfalls eine ganze Zahl ist. Wie 1 oder -1)” geben. Mit anderen Worten, die eigentliche Elementgleichung sieht so aus:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

($u$ ist ein Element der Einheitengruppe $U_K$)

Wenn diese Einheit $u$ nicht selbst das Quadrat von etwas ist, kann die linke Seite niemals ein “perfektes Quadrat eines Elements” werden.

Phase 5: Adlemans Magie “Quadratische Charaktere” (Quadratic Characters)

Das Hindernis der Idealklassengruppe und das Hindernis der Einheitengruppe. Wie können wir diese beiden überwinden? Hier kommt die brillante Methode der “Quadratischen Charaktere (Quadratic Characters)” ins Spiel, die von dem Kryptographen Leonard Adleman (das “A” von RSA) und anderen eingeführt wurde.

Um festzustellen, “ob ein bestimmtes Element ein perfektes Quadrat im algebraischen Körper ist”, verwenden wir die Zahlkörper-Version des Legendre-Symbols (quadratischer Rest). In dieser riesigen Matrix (dem Rätsel, um die Primidealzählungen gerade zu machen), fügen wir heimlich ein paar Dutzend zusätzliche Bedingungen (Spalten) hinzu, die besagen: “Die quadratischen Charaktere für einige spezielle Primideale $\mathfrak{q}$ müssen ebenfalls alle $1$ (gerade) sein” .

Wenn wir eine Menge $S$ finden, die durch die Matrixberechnung sogar diese zusätzliche Bedingungen erfüllt, garantieren tiefe Sätze aus der algebraischen Zahlentheorie, dass “sowohl das Hindernis der Idealklassengruppe als auch das Hindernis der Einheitengruppe mit überwältigender Wahrscheinlichkeit natürlich verschwinden werden” .

Damit erhalten wir endlich die wahre Gleichung.

$$\prod_{S} (a - b\alpha) = \gamma^2$$

Letzte Phase: Die Verschmelzung der Welten und der Zusammenbruch der Kryptographie

Endlich sind alle Puzzleteile an ihrem Platz.

[Elemente in der Welt der algebraischen Körper (Welt A)] $\gamma^2 = \prod (a - b\alpha)$ (Wir verwenden einen Quadratwurzel-Algorithmus, um $\gamma$ zu finden)

[Elemente in der realen Welt (Welt der rationalen Zahlen)] $V^2 = \prod (a - bm)$ (Da dies eine einfache Ganzzahlmultiplikation ist, $V$ normal gefunden werden kann)

Nun ist es Zeit für die magische Brücke, die wir zu Beginn gebaut haben, den Homomorphismus $\phi$ . Wir teleportieren das Element $\gamma$ aus Welt A nach Welt B (die Welt der Reste von $N$) mithilfe von $\phi$ (die Abbildung, bei der wir $\alpha$ durch $m$ ersetzen).

$$Y = \phi(\gamma) \pmod N$$

Andererseits bringen wir das in der realen Welt gebaute $V$ direkt in die Restewelt und nennen es $X$.

$$X = V \pmod N$$

Aufgrund der “strukturerhaltenden” Eigenschaft des Homomorphismus bleibt die quadratische Beziehung, die in Welt A galt, in Welt B (der Welt modulo $N$) perfekt erhalten. Da die ursprünglichen Paare $(a, b)$ außerdem in Entsprechung in den Formen $a - b\alpha$ und $a - bm$ erzeugt wurden, kollidieren diese $X$ und $Y$ in der Welt modulo $N$ und erzeugen die folgende absolute Gleichung:

$$X^2 \equiv Y^2 \pmod N$$

Alles, was bleibt, ist zu beten, dass diese $X$ und $Y$ keine trivialen Lösungen ($X \equiv \pm Y$) sind, und $\gcd(X - Y, N)$ zu berechnen.

Wenn es sich um eine nicht-triviale Lösung handelt, durchläuft der Euklidische Algorithmus sie in 0,001 Sekunden, und die geheimen Primzahlen $p$ und $q$, die das Herzstück der RSA-Kryptographie bilden, werden auf dem Ausgabebildschirm gedruckt.

Dies ist das vollständige Bild des “Allgemeinen Zahlkörpersiebs (GNFS)” , der Essenz der modernen Mathematik.

Was ist das "General Number Field Sieve (GNFS)", die stärkste Mathematik der Menschheit, die die Internetverschlüsselung knackt?

Sat, 05 Sep 2026 02:09:08 +0900

Was ist das “General Number Field Sieve (GNFS)”, die stärkste Mathematik der Menschheit, die die Internetverschlüsselung knackt?

Das Internet, das wir jeden Tag nutzen. LINE-Nachrichten, YouTube, Einkaufen auf Amazon – die gesamte Kommunikation wird durch “Verschlüsselung” geschützt. Derzeit ist der weltweit am häufigsten verwendete Vertreter die “RSA-Verschlüsselung”.

Der Schlüssel zur Verteidigung der RSA-Verschlüsselung ist sehr einfach. Er nutzt die mathematische Eigenschaft, dass ** “die Primfaktorzerlegung gigantischer Zahlen selbst von Computern nicht gelöst werden kann” ** . Bei “15” wissen wir zum Beispiel sofort, dass es “3 × 5” ist, aber sobald es eine “270-stellige Zahl” wird, würde es Hunderte von Millionen Jahren dauern, selbst wenn man alle Supercomputer der Welt zusammennimmt, um sie zu lösen.

Doch die Mathematiker sind nicht stumm geblieben. Um diese undurchdringliche Verschlüsselung zu knacken, hat die Menschheit einen fast magischen Algorithmus (Berechnungsverfahren) namens ** “General Number Field Sieve (GNFS)” ** erschaffen.

In diesem Artikel werden wir ohne Fachjargon und nur mit dem Wissen der ** Mittelstufenmathematik (Primfaktorzerlegung, algebraische Ausdrücke, größter gemeinsamer Teiler) ** Schritt für Schritt erklären, wie dieser “stärkste Algorithmus der Menschheit” die Verschlüsselung knackt!

Kapitel 1: Das Ziel der Entschlüsselung ist eine “Formel der 9. Klasse”

Der größte Spezialtrick, um der gigantischen Primfaktorzerlegung zu begegnen. Es ist diese Formel, die man in der 9. Klasse lernt:

** $X^2 - Y^2 = (X + Y)(X - Y)$ **

Sie denken vielleicht: “Ernsthaft, eine so grundlegende Formel kann Verschlüsselung knacken?”. Dies ist jedoch der Hauptschlüssel, der alles offenbart.

Das größte Ziel beim Knacken der Verschlüsselung ist es, für eine riesige Zahl $N$, ** “Zahlen ($X$ und $Y$) zu finden, bei denen der Rest bei der Division von $X^2$ und $Y^2$ durch $N$ derselbe ist” ** .

Warum knackt “derselbe Rest” die Verschlüsselung?

Angenommen, zwei Zahlen, $X^2$ und $Y^2$, haben “denselben Rest, wenn sie durch $N$ geteilt werden”. Denselben Rest zu haben bedeutet, dass es eine Regel nach der ** die Subtraktion “$X^2 - Y^2$” immer genau durch $N$ teilbar ist (ein Vielfaches von $N$ sein wird) ** .

Nehmen wir hier an, dass die gigantische Zahl $N$, die für die Verschlüsselung verwendet wird, aus der Multiplikation zweier geheimer Primzahlen ($p$ und $q$) besteht ($N = p \times q$).

Wenn wir $X^2 - Y^2$ faktorisieren, erhalten wir ** $(X - Y)(X + Y)$ ** . Die Tatsache, dass dies ein Vielfaches von $N$ ist, bedeutet, dass irgendwo in dieser Multiplikation die geheimen Primzahlen $p$ und $q$ verborgen sind.

Hier geschieht ein Wunder. Es besteht eine mathematische Wahrscheinlichkeit von ** 50% (der Hälfte) ** , dass die beiden Primzahlen $p$ und $q$ sich in verschiedene Räume trennen: ** “$p$ geht in den Raum von $(X - Y)$” und “$q$ geht in den Raum von $(X + Y)$” ** .

Wenn nur die Primzahl $p$ den Raum von $(X - Y)$ betreten hat, berechnen wir den ** “größten gemeinsamen Teiler (das größte gemeinsame Teil)” ** von $(X - Y)$ und $N$.

Inhalt von $(X - Y)$ = $p \times$ irgendeine Zahl
Inhalt von $N$ = $p \times q$ Das einzige gemeinsame Teil ist ** “$p$” ** !

Mit anderen Worten, in dem Moment, in dem der größte gemeinsame Teiler berechnet wird, wird die verborgene Primzahl $p$ enthüllt und die Verschlüsselung ist vollständig entschlüsselt. (*Der größte gemeinsame Teiler kann sogar auf einem Smartphone sofort mit dem “Euklidischen Algorithmus” berechnet werden).

** 【Kleine Kolumne: Warum das Quadrat? Funktionieren Kubik oder das Doppelte nicht?】 **

Bei “$2X - 2Y$” wird es zu $2(X - Y)$ und es gibt nur einen Raum, sodass Sie die Primzahlen nicht trennen können. Bei “$X^3 - Y^3$” wird die Größe der Räume unausgewogen und die Berechnung wird unnötig schwer. Um die Primzahlen in zwei zu trennen, ist das “Quadrat”, das sich wunderbar in zwei Räume aufteilt, am kostengünstigsten.

Kapitel 2: Wie findet man X und Y? “Das Primzahlkarten-Sammelpuzzle”

Das Ziel ist klar. Doch selbst wenn wir blind nach “$X^2$ und $Y^2$ mit demselben Rest” suchen würden, würde das Ende des Universums eintreten, bevor wir sie finden. Also ließen sich Mathematiker eine geniale Methode namens ** “Primzahlkarten-Sammelpuzzle” ** einfallen.

Schritt 1: Nur Goldstaub (glatte Zahlen) mit einem Sieb sammeln

Bereiten Sie zunächst eine geeignete Zahl $Z$ vor, quadrieren Sie sie und berechnen Sie den Rest $W$, wenn sie durch $N$ geteilt wird. (Die Restwelt von $Z^2 = W$)

Faktorisieren Sie den erhaltenen Rest $W$ in Primzahlen. Hier gilt: Nur wenn ** “ein $W$, das nur aus kleinen Primzahlen wie 2, 3, 5, 7 usw. besteht” ** , erscheint, behalten Sie diese Gleichung als “Gewinnerkarte” und werfen Sie sie weg, wenn große Primzahlen beigemischt sind. Es ist wie das Wegwerfen großer Steine mit einem Sieb in einem Fluss, um nur Goldstaub zu sammeln.

Schritt 2: Das Puzzle, um alles “gerade” zu machen

Nehmen wir zum Beispiel an, die folgenden 3 Goldstaubkarten wurden gesammelt.

Karte A: $Z_1^2 = 2^3 \times 3^1$
Karte B: $Z_2^2 = 2^1 \times 5^1$
Karte C: $Z_3^2 = 3^1 \times 5^1$

Lassen Sie uns alle multiplizieren. Die rechte Seite wird zu $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, Und wenn man alles ordnet, wird es zu ** “$2^4 \times 3^2 \times 5^2$” ** .

Überraschenderweise wurde die Anzahl der Primzahlen zu “4, 2, 2”, ** allesamt eine gerade Zahl ** ! Dass alle gerade sind, bedeutet, dass wenn man die Gesamtmenge halbiert, es “das Quadrat von etwas” sein wird. Mit anderen Worten, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Die linke Seite ist $(Z_1 \times Z_2 \times Z_3)^2$, also sind wir endlich am Ziel: ** $X = (Z_1 \times Z_2 \times Z_3)$ ** ** $Y = 60$ ** Das lang ersehnte Paar von “$X^2 = Y^2$” ist komplett!

Für Computer ist das Puzzle, zu berechnen, ob die Anzahl der Primzahlen “gerade oder ungerade (0 oder 1)” ist, etwas, worin sie sehr gut sind, sodass mit dieser Methode $X$ und $Y$ mit hoher Geschwindigkeit gefunden werden können.

Kapitel 3: Die Mauer der Verzweiflung

Jetzt kann jeder Code geknackt werden! …oder das dachten wir zumindest, aber ein großes Problem tritt auf. Wenn die Verschlüsselungszahl $N$ bis zu “100 Stellen” umfasst, kann diese Methode (Quadratisches Sieb genannt) sie lösen, aber wenn $N$ zu “200 oder 300 Stellen” wird, wird das in der Mitte der Berechnung auftretende $W$ viel zu groß.

Wenn die Zahlen zu groß werden, tauchen “Zahlen, die nur aus kleinen Primzahlen (Goldstaub) bestehen”, einfach nicht mehr auf. Es wird schwieriger, als eine Kontaktlinse in der Wüste zu suchen, und die zum Lösen des Puzzles benötigten Karten sammeln sich gar nicht erst an.

Hier tritt schließlich die ultimative Waffe der Menschheit, das ** “General Number Field Sieve (GNFS)” ** , auf den Plan.

Kapitel 4: Die stärkste Idee der Menschheit, “Zwei Welten” zu erschaffen

Die geniale Idee des GNFS ist: ** “Die Zahlen werden gigantisch, weil wir nur in der realen Welt rechnen. Lassen Sie uns also eine ‘Hinterwelt’ mit Polynomen (Buchstabenformeln) erschaffen, um das Gewicht der Berechnung in zwei Hälften zu teilen.” **

Die Magie der Buchstabenformeln

GNFS wandelt die riesige Zahl $N$ unter Verwendung einer Basiszahl $m$ in einen Buchstabenausdruck um. Wenn zum Beispiel $N=100$ ist, mit $m=4$, dann ist $100 = 4^3 + 2(4^2) + 4$. Mit dem Buchstaben $x$ machen wir daraus eine Formel (die Hinterwelt): ** $f(x) = x^3 + 2x^2 + x$ ** .

Das Interessante an dieser Formel ist, dass sie die Eigenschaft hat, ** “wenn Sie $x$ durch $m$ ersetzen (4 im obigen Beispiel), können Sie immer zur realen Zahl $N$ zurückkehren” ** .

Gleichzeitig in 2 Welten nach Goldstaub suchen

GNFS erzeugt viele Paare von zufälligen Ganzzahlen $(a, b)$ und führt gleichzeitig die folgenden zwei Berechnungen durch:

** Reale Welt ** : $a - b \times m$
** Buchstabenwelt ** : Der Wert von $a - b \times x$, berechnet nach den Regeln der Polynome

Durch die Aufteilung des Problems in zwei Welten verringert sich die Größe (das Gewicht) der verarbeiteten Zahlen drastisch. Es ist, als würde man einen riesigen Felsen in zwei handliche Steine spalten.

Dann trennen und sammeln Sie mit einem Sieb nur die Wunderpaare $(a, b)$, bei denen ** “sowohl in der realen Welt als auch in der Buchstabenwelt beide ’nur aus kleinen Primzahlen (Goldstaub) bestehen’” ** . Daher der Name “Zahlkörpersieb” (Number Field Sieve).

Der Moment, in dem die Verschlüsselung endlich geknackt wird

Sobald Dutzende Millionen von “Goldstaubkarten” aus beiden Welten gesammelt wurden, verwendet der Supercomputer gigantische Matrixberechnungen, um “eine Kombination zu finden, bei der die Anzahl der Primzahlen alle gerade ist”, genau wie wir es in Kapitel 2 getan haben.

Sobald die Kombination gefunden ist:

Sei die Quadratzahl in der realen Welt ** $X^2$ **
Sei die in der Buchstabenwelt erstellte Quadratformel ** $Y(x)^2$ **

Ersetzen Sie schließlich das $x$ in der Buchstabenformel $Y(x)$ durch $m$, springen Sie in die reale Welt zurück und verbinden Sie sie. Dann ist, wie durch mathematische Magie, die Bedingung erfüllt, dass ** “die Reste von $X^2$ und $Y^2$ gleich sind” ** !

Der Rest besteht, wie in Kapitel 1, lediglich darin, den größten gemeinsamen Teiler von $X - Y$ und $N$ zu berechnen, und die uneinnehmbare RSA-Verschlüsselung wird zusammenbrechen und die geheimen Primzahlen offenbaren.

Fazit: Die Mathematik endet nie

Sie denken vielleicht: “Großartig, mit GNFS kann jede Verschlüsselung geknackt werden!”. Doch auch die RSA-Verschlüsselung hat nicht aufgegeben. Was im heutigen Internet verwendet wird, ist eine monströs gigantische Zahl namens “RSA-2048 (ca. 617 Stellen)”.

Obwohl GNFS der stärkste Algorithmus der Menschheit ist, sagt man, dass selbst das Lösen von 270 Stellen (RSA-270) Tausende oder Zehntausende von Jahren dauern würde, selbst wenn man Computer auf der ganzen Welt miteinander verbindet. Vorerst sind unsere LINE- und Bankdaten sicher.

Aber was wäre, wenn eine ** “Magie, um $X$ und $Y$ für jede riesige Zahl sofort zu finden” ** , auftauchen würde? Tatsächlich kommt der ** “Quantencomputer (Shor-Algorithmus)” ** , der sich derzeit in der Entwicklung befindet, dem am nächsten. Unter Ausnutzung der Wellennatur der Quantenmechanik wurde mathematisch bewiesen, dass es möglich ist, das mühsame Kartensammelpuzzle zu umgehen und die Antwort auf einen Schlag zu finden.

Ein endloser Kampf des Verstandes zwischen denen, die Verschlüsselung erschaffen (Verteidigung), und denen, die Algorithmen entwickeln, um sie zu knacken (Angriff). Macht das Wissen, dass die in der Mittelstufe erlernte “Primfaktorzerlegung” und “algebraische Ausdrücke” tatsächlich die Waffen sind, die an vorderster Front der globalen Sicherheit kämpfen, den Mathematikunterricht nicht ein wenig interessanter?

Derjenige, der den stärksten Algorithmus der Zukunft entdeckt, könnten Sie sein, der diesen Artikel liest!

(※Dieser Artikel ist eine konzeptionelle Adaption der mathematischen Faszination des Codeknackens für Schüler. Das eigentliche GNFS wird streng mit Hilfe der fortgeschrittenen Universitätsmathematik, wie Idealklassengruppen algebraischer Zahlkörper und Homomorphismen, berechnet)

Die Kepler-Vermutung Einfach Erklärt

Mon, 21 Jul 2025 22:53:03 +0900

Die Kepler-Vermutung Einfach Erklärt! Der beste Weg, Wassermelonen zu verpacken

Hallo, ich bin kenji!

Heute möchte ich versuchen, ein mathematisches Thema mit einem etwas kompliziert klingenden Namen, die “Kepler-Vermutung”, so einfach wie möglich zu erklären.

Auf den ersten Blick mag das wie ein Thema für Nerds wirken, aber es ist auch ein sehr alltägliches Problem: “Wie können wir Wassermelonen am dichtesten in eine Kiste packen?”. Es hat auch etwas mit den Kühlschränken in Convenience-Stores und dem Stapeln von Fracht zu tun.

Und in der Welt der Mathematik verbirgt sich dahinter eine super romantische Geschichte: dass dies über 400 Jahre lang nicht bewiesen werden konnte .

Lass uns anfangen!

Wer war Kepler eigentlich?

Zunächst einmal: Wer ist der “Kepler” in der “Kepler-Vermutung”?

Es ist der Name eines deutschen Astronomen und Mathematikers namens Johannes Kepler .

Dieser Typ war unglaublich. Er war zum Beispiel derjenige, der entdeckte, dass die Planetenbahnen elliptisch sind. Das ist heute Allgemeinwissen, aber damals (um 1600) war es eine Ära, in der selbst das heliozentrische Weltbild kaum geglaubt wurde.

Galileo = Genie der Beobachtung
Kepler = das Genie, das das Universum mit mathematischen Formeln erklärte
Newton = das Supergenie, das diese Theorie in physikalischen Gesetzen zusammenfasste

Mit dieser Positionierung war Kepler ein Pionier darin, “mit mathematischen Formeln über das Universum zu sprechen”.

Und irgendwann sagte er Folgendes:

Was ist die Kepler-Vermutung?

Kurz gesagt, ist die “Kepler-Vermutung” wie folgt.

Beim Verpacken von Kugeln gleicher Größe (Wassermelonen oder Orangen) in eine Kiste, welche Anordnung ermöglicht die dichteste Packung?

Das ist das Problem.

Und was Kepler in den 1600er Jahren vermutete, war:

Wäre es nicht am effizientesten, sie wie Dreiecke zu stapeln, ähnlich wie Gemüsehändler Orangen auslegen?

In der mathematischen Sprache wird dies das “Dichteste Kugelpackung-Problem” (Sphere Packing) genannt, welches nach der Methode sucht, Kugeln so dicht wie möglich in einem Raum anzuordnen.

Kepler vermutete, dass die Anordnung, die “kubisch flächenzentrierte Struktur (FCC)” genannt wird (wie das Stapeln von Wassermelonen in einem Dreiecksmuster), am effizientesten wäre.

Jeder dachte: “Ja, das macht Sinn…”, aber es mathematisch zu beweisen, dass “dies absolut das Beste ist!”, war extrem schwierig.

400 Jahre für den Beweis!?!

Wann wurde es also tatsächlich bewiesen…?

Erstaunlicherweise etwa zwischen 1998 und 2005 . Das heißt, fast 400 Jahre lang konnte es niemand beweisen . Das ist verrückt.

Darüber hinaus war die Person, die es bewies, ein amerikanischer Mathematiker namens Thomas Hales .

Er erkannte, dass es unmöglich wäre, dies nur mit manuellen Berechnungen zu tun, also nutzte er Computer für den Beweis . Es trat jedoch ein Problem auf: Der Beweis war so komplex, dass Menschen ihn nicht richtig überprüfen konnten!

So entbrannte auch in der mathematischen Welt eine große Debatte: “Können wir einem Beweis, der von Computern gemacht wurde, wirklich vertrauen?”.

Schließlich wurde der Beweis (offiziell “formaler Beweis” genannt), der besagte: “Ich habe ihn rigoros überprüft, einschließlich der Computer!”, im Jahr 2014 abgeschlossen.

Mit anderen Worten, es hat über 400 Jahre gedauert zu beweisen, dass Keplers Intuition richtig war . Was für eine Romanze.

Sehr oft im echten Leben verwendet

Man könnte denken, dass “wie man Kugeln anordnet” ein Thema nur für Mathe-Freaks ist, aber in Wirklichkeit ist es sehr praktisch.

Um Getränke effizient in Kühlschränken von Convenience-Stores zu verpacken
Beim Stapeln von Dosen auf Transportpaletten
Es wird auch in der Kommunikation angewendet (Kompression digitaler Signale usw.)
Wird beim Entwurf von 3D-Druckern und Kristallstrukturen verwendet

Usw. Es ist tatsächlich eine Theorie, die massiv hinter den Kulissen unseres Lebens genutzt wird.

Fazit: Die menschliche Intuition ist erstaunlich

Lassen Sie uns zusammenfassen.

Kepler-Vermutung = Das Problem, wie man Kugeln am dichtesten verpackt
Herr Kepler = Mathematiker und Astronom, der die Planetenbahnen entdeckte
In den 1600er Jahren vermutet! Aber in den 2000er Jahren bewiesen!
Sehr anwendbar im echten Leben!

Und der interessanteste Punkt ist: “Die Art zu stapeln, die Gemüsehändler aus Intuition gemacht haben, war mathematisch auch die stärkste” .

Mit anderen Worten: Die menschliche Intuition ist erstaunlich . Und die Tatsache, dass es 400 Jahre dauern kann, dies zu beweisen , ist eine wirklich romantische Geschichte, nicht wahr?

Wenn Sie interessiert sind, suchen Sie unbedingt nach “Thomas Hales”, “formaler Beweis”, “Sphere Packing”. Es macht sehr viel Spaß, tiefer einzutauchen.

Bis dann!

[PR]

今すぐ購入

P≠NP-Vermutung

Wed, 11 Sep 2024 02:22:39 +0900

Überblick

1

Die Klasse P ist die Klasse von Problemen, die in polynomieller Zeit von einer deterministischen Turingmaschine entschieden werden können, und die Klasse NP ist die Klasse von Problemen, bei denen bei Vorliegen eines Beweises (genannt Witness oder Zeuge) für die Antwort "Ja" die Gültigkeit des Witness in polynomieller Zeit beurteilt (das nennt man Verifikation) werden kann. Da in polynomieller Zeit entscheidbare Probleme in polynomieller Zeit verifiziert werden können, ist offensichtlich P⊆NP, aber es ist nicht klar, ob P eine echte Teilmenge von NP ist. Es gibt noch keinen Beweis, aber viele Forscher glauben, dass P≠NP ist. Die Vermutung, dass diese Klasse P und Klasse NP nicht gleich sind, wird als "P≠NP-Vermutung" bezeichnet.

Referenzseite : https://daigakudenki.com/np-hard/

C-Code zur Generierung von Primzahlen

Sat, 24 Aug 2024 09:38:10 +0900

Nachfolgend finden Sie einen einfachen C-Code, der Primzahlen innerhalb eines bestimmten Bereichs generiert. In diesem Beispiel zählen wir Primzahlen von 1 bis n auf.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Bitte geben Sie den Maximalwert des Bereichs ein, um Primzahlen zu generieren: ");
 scanf("%d", &n);
 printf("Die Primzahlen von 1 bis %d sind wie folgt:\n", n);
 printPrimes(n);
 return 0;
}

Dieser Code funktioniert wie folgt:

Funktion isPrime: Bestimmt, ob eine gegebene Zahl eine Primzahl ist. Aus Effizienzgründen wird zunächst geprüft, ob sie durch 2 und 3 teilbar ist, und dann in Vielfachen von 6 weitergeprüft.
Funktion printPrimes: Gibt die Primzahlen innerhalb eines bestimmten Bereichs aus. Die 2 wird zuerst ausgegeben, und dann werden nur ungerade Zahlen überprüft.
Funktion main: Fordert den Benutzer auf, den Maximalwert des Bereichs einzugeben, und gibt die Primzahlen innerhalb dieses Bereichs aus.

Wenn Sie diesen Code kompilieren und ausführen, werden die Primzahlen innerhalb des angegebenen Bereichs angezeigt.

Einführung in Mathematica

Thu, 25 Jul 2024 01:36:19 +0900

Einführung in Mathematica

Gleichungen lösen

1

Solve[x^2 - 3 x + 2 == 0, x]

Ausgabe

1

{{x -> 1}, {x -> 2}}

Lösungen von Gleichungen im Bereich der ganzen Zahlen finden

1

Solve[x^2 - 3 x + 2 == 0 && 0 <= x <= 2, x, Integers]

Ausgabe

1

{{x -> 1}, {x -> 2}}

Gleichungssysteme lösen

1

Solve[{x + y == 3, x - y == 1}, {x, y}]

Ausgabe

1

{{x -> 2, y -> 1}}

Ungleichungen lösen

1

Reduce[x^2 - 3 x + 2 > 0, x]

Ausgabe

1

x < 1 || x > 2

Ableiten

1

D[x^2, x]

Ausgabe

1

2 x

Integrieren

1

Integrate[x^2, x]

Ausgabe

1

x^3/3

Grenzwerte berechnen

1

Limit[1/x, x -> 0]

Ausgabe

1

Infinity

Reihen berechnen

1

Sum[1/n^2, {n, 1, Infinity}]

Ausgabe

1

π^2/6

Matrix erstellen

1

m = {{1, 2}, {3, 4}}

Matrixprodukt berechnen

1

m . m

Ausgabe

1

{{7, 10}, {15, 22}}

Inverse Matrix berechnen

1

Inverse[m]

Ausgabe

1

{{-2, 1}, {1.5, -0.5}}

Eigenwerte und Eigenvektoren berechnen

1

Eigensystem[m]

Ausgabe

1

{{5, 0}, {{1, 1}, {1, -1}}}

Skalarprodukt von Vektoren berechnen

1

{1, 2} . {3, 4}

Ausgabe

1

11

Kreuzprodukt von Vektoren berechnen

1

Cross[{1, 2, 3}, {4, 5, 6}]

Ausgabe

1

{-3, 6, -3}

Betrag eines Vektors berechnen

1

Norm[{1, 2, 3}]

Ausgabe

1

√14

Winkel von Vektoren berechnen

1

ArcCos[{1, 2} . {3, 4}/(Norm[{1, 2}] Norm[{3, 4}])]

Ausgabe

1

ArcCos[11/(√5 √25)]

Projektion von Vektoren berechnen

1

{1, 2} . {3, 4}/Norm[{3, 4}] {3, 4}/Norm[{3, 4}]

Ausgabe

1

{11/5, 22/5}

Rotation von Vektoren berechnen

1

RotationMatrix[π/2].{1, 0}

Ausgabe

1

{0, 1}

Translation von Vektoren berechnen

1

TranslationTransform[{1, 2}][{3, 4}]

Ausgabe

1

{4, 6}

Skalierung von Vektoren berechnen

1

ScalingTransform[{2, 3}][{1, 1}]

Ausgabe

1

{2, 3}

Reflexion von Vektoren berechnen

1

ReflectionTransform[{1, 1}][{1, 1}]

Ausgabe

1

{0, 0}

Zufallszahlen generieren

1

RandomReal[]

Ausgabe

1

0.123456

Zufallszahlen generieren (ganze Zahlen)

1

RandomInteger[]

Ausgabe

1

123456

Zufallszahlen generieren (Bereich angegeben)

1

RandomReal[{1, 10}]

Ausgabe

1

5.6789

Zufallszahlen generieren (ganze Zahlen, Bereich angegeben)

1

RandomInteger[{1, 10}]

Ausgabe

1

5

Zufallszahlen generieren (Verteilung angegeben)

1

RandomVariate[NormalDistribution[0, 1]]

Ausgabe

1

0.123456

Zufallszahlen generieren (Verteilung, Menge angegeben)

1

RandomVariate[NormalDistribution[0, 1], 10]

Ausgabe

1

{0.123456, 0.234567, ..., 0.987654}

Zufallszahlen generieren (Verteilung, Menge, Seed angegeben)

1
2


SeedRandom[12345]
RandomVariate[NormalDistribution[0, 1], 10]

Ausgabe

1

{0.123456, 0.234567, ..., 0.987654}

Funktion auf Array-Elemente anwenden

1
2
3


Map[Sqrt, {1, 4, 9}]
Sqrt /@ {1, 4, 9}
Map[#^(1/2)&, {1, 4, 9}]

Ausgabe

1

{1, 2, 3}

Funktion mit Lambda-Ausdrücken definieren

1
2


f = Function[x, x^2]
f[3]

Ausgabe

1

9

Funktionen komponieren

1
2
3
4


f = Function[x, x^2]
g = Function[x, x + 1]
h = Function[x, f[g[x]]]
h[3]

Ausgabe

1

16

Auf vorheriges Berechnungsergebnis verweisen

1

% + 1

Ausgabe

1

17

Reine Funktion

1

(#+3)&[5]

Ausgabe

1

8

Array extrahieren

1
2


Select[{1, 2, 3, 4, 5}, EvenQ]
Select[{1, 2, 3, 4, 5}, Mod[#,2]==0&]

Ausgabe

1

{2, 4}

Was ist das Geburtstagsparadoxon?

Tue, 02 Apr 2024 01:20:50 +0900

Kennen Sie das Geburtstagsparadoxon?

Ich werde Ihnen eine etwas seltsame Geschichte erzählen. Wie viele Personen müssen Ihrer Meinung nach zusammenkommen, damit “die Wahrscheinlichkeit, dass Personen am selben Tag Geburtstag haben”, hoch ist?

Ein Jahr hat zum Beispiel 365 Tage. Wenn man Ihnen also sagt: “Wenn 23 Personen zusammenkommen, liegt die Wahrscheinlichkeit, dass jemand denselben Geburtstag hat, bei über 50 %”… dann scheint das irgendwie gegen die Intuition zu verstoßen.

Aber es sind tatsächlich über 50 %.

Warum passiert das?

Dieses Phänomen wird als “Geburtstagsparadoxon” bezeichnet. Der Name lautet “Paradoxon”, aber es gibt einen fundierten mathematischen Grund.

Wenn die Anzahl der Personen “n” ist, wird die Wahrscheinlichkeit, dass niemand denselben Geburtstag hat , durch die folgende Formel berechnet:

1

P(niemand hat am selben Tag Geburtstag) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

Indem man dies von 1 abzieht, erhält man “die Wahrscheinlichkeit, denselben Geburtstag wie jemand anderes zu haben”.

Wenn wir uns die Ergebnisse ansehen…

Anzahl der Personen	Wahrscheinlichkeit, denselben Geburtstag zu haben
10 Personen	Etwa 11.7%
20 Personen	Etwa 41.1%
23 Personen	Etwa 50.7% (Hierauf achten!)
30 Personen	Etwa 70.6%
70 Personen	Erstaunliche 99.9%!

Das heißt, bei nur 23 Personen besteht eine Wahrscheinlichkeit von mehr als der Hälfte, dass jemand denselben Geburtstag hat. Dies lässt sich durchaus auch auf Schulklassen oder Besprechungen am Arbeitsplatz übertragen.

Zusammenfassung: Die Diskrepanz zwischen Intuition und Mathematik ist faszinierend

Das “Geburtstagsparadoxon” ist ein interessantes Beispiel dafür, wie unsere Intuition und die tatsächliche mathematische Wahrscheinlichkeit voneinander abweichen. Solche Dinge zu wissen, kann eine nette Unterhaltung oder ein Quiz auflockern!

Referenz-Links

Geburtstagsparadoxon (Wikipedia)

Das Ziegenproblem (Monty-Hall-Problem)

Sun, 31 Mar 2024 23:41:51 +0900

Was ist das Ziegenproblem?

Das Ziegenproblem (Monty-Hall-Problem) ist ein Spiel aus der amerikanischen Fernsehshow “Let’s Make a Deal” und lässt sich wie folgt beschreiben:

Voraussetzungen: Hinter einer von 3 Türen befindet sich ein Preis, hinter den anderen 2 Nieten (Ziegen).

Der Teilnehmer wählt eine der 3 Türen.
Der Moderator öffnet eine der 2 vom Teilnehmer nicht gewählten Türen, hinter der sich eine Niete befindet.
Der Teilnehmer wird gefragt, ob er die gewählte Tür wechseln möchte.

Bei diesem Problem geht es darum zu überlegen, ob es für den Teilnehmer besser ist, die Tür zu wechseln oder nicht.

Lösung

Die Lösung für das Ziegenproblem lautet wie folgt:

Wenn der Teilnehmer die ursprünglich gewählte Tür nicht wechselt
- Gewinnwahrscheinlichkeit: 1/3
- Verlustwahrscheinlichkeit: 2/3
Nachdem der Moderator eine Tür mit einer Niete geöffnet hat
- Beim Nicht-Wechseln, Gewinnwahrscheinlichkeit: 1/3 (bleibt gleich wie in 1.)
- Beim Wechseln, Gewinnwahrscheinlichkeit: 2/3 (die Wahrscheinlichkeit für alles andere aus 1.)

Daher ist die Gewinnwahrscheinlichkeit höher, wenn der Teilnehmer die Tür wechselt.

Referenz

Wikipedia Monty Hall problem

Ungelöste Probleme in der Mathematik

Sat, 02 Mar 2024 22:57:36 +0900

Ungelöste Probleme in der Mathematik

Ich werde ungelöste Probleme der Mathematik erklären. Obwohl die Probleme selbst einfach sind, gibt es noch viele Probleme, die nicht bewiesen wurden.

Gibt es unendlich viele vollkommene Zahlen?

Eine vollkommene Zahl ist eine natürliche Zahl, deren Summe ihrer positiven echten Teiler (ohne sich selbst) gleich der Zahl selbst ist. Zum Beispiel,

Die Teiler von 6 sind 1, 2, 3 und da 1+2+3=6 ist, ist es eine vollkommene Zahl.
Die Teiler von 28 sind 1, 2, 4, 7, 14 und da 1+2+4+7+14=28 ist, ist es eine vollkommene Zahl.

Derzeit wurden nur 51 entdeckt. Man vermutet, dass es unendlich viele gibt, aber es wurde noch nicht bewiesen.

Goldbachsche Vermutung

Die Goldbachsche Vermutung besagt, dass jede gerade Zahl größer als 2 als Summe zweier Primzahlen dargestellt werden kann. (Hierbei ist eine Primzahl eine natürliche Zahl, die außer 1 und sich selbst keine weiteren Teiler hat.)

Zum Beispiel,

4=2+2
6=3+3
8=3+5
10=3+7=5+5

Das Problem selbst ist sehr einfach, aber es wurde noch nicht bewiesen.

Riemannsche Vermutung

Die Riemannsche Vermutung besagt, dass die Nullstellen der Riemannschen Zeta-Funktion auf negative gerade Zahlen und komplexe Zahlen mit einem Realteil von 1/2 beschränkt sind.

Die Riemannsche Zeta-Funktion ist die Funktion $\zeta$, die definiert ist durch (wenn $s$ eine komplexe Zahl und $n$ eine natürliche Zahl ist):

$$\zeta(s):=\sum _{n=1}^{\infty }{\frac {1}{n^{s}}}=1+{\frac {1}{2^{s}}}+{\frac {1}{3^{s}}}+{\frac {1}{4^{s}}}+\cdots$$

Geschichte der Mathematik

Sat, 22 Jul 2023 15:25:10 +0900

Die drei klassischen Probleme der Antike

Zu einem gegebenen Kreis ein flächengleiches Quadrat konstruieren (Quadratur des Kreises)
Einen beliebigen Winkel in drei gleiche Teile teilen (Dreiteilung des Winkels)
Zu einem gegebenen Würfel einen Würfel mit doppeltem Volumen konstruieren (Verdoppelung des Würfels)

Archimedische Spirale

In einer Ebene dreht sich ein Halbstrahl OB mit gleichmäßiger Geschwindigkeit um einen festen Punkt O. Wenn die Ausgangsposition OA ist und gleichzeitig ein Punkt P von O aus startet und sich mit konstanter Geschwindigkeit entlang OB bewegt, ist die von Punkt P gezeichnete Kurve die Archimedische Spirale.

Satz des Pappos

Zykloide
Konchoide des Nikomedes
Zissoide des Diokles
Tangentenmethode von Fermat
Normalenmethode von Descartes

Chronologie

Jahr	Ereignis
ca. 3400 v. Chr.	Die Sumerer verwenden Tonzählmarken für die Buchhaltung
ca. 3000 v. Chr.	Hieroglyphische Mathematik taucht in Ägypten auf
ca. 2800 v. Chr.	Die Indus-Kultur verwendet dezimale Maße und Gewichte
ca. 2700 v. Chr.	Die Ägypter verwenden Seile und pythagoreische Tripel zur Winkelprüfung
ca. 2500 v. Chr.	Der Abakus, ein Rechenwerkzeug, wird entdeckt
ca. 2500 v. Chr.

Referenz

Geschichte der Mathematik

Wie man Primzahlen unter 1000 mit dem Sieb des Eratosthenes auflistet

Sun, 09 Apr 2023 12:54:24 +0900

Was ist das Sieb des Eratosthenes?

Das Sieb des Eratosthenes ist ein Algorithmus, mit dem alle Primzahlen bis zu einem bestimmten Grenzwert gefunden werden können. Der Algorithmus ist einfach und kann durch die folgenden Schritte implementiert werden:

Erstellen Sie ein boolesches Array mit N Elementen und initialisieren Sie alle Elemente auf wahr (true).
Setzen Sie das nullte und das erste Element des Arrays auf falsch (false) (da 0 und 1 keine Primzahlen sind).
Wenn das 2. Element des Arrays wahr ist, geben Sie 2 als Primzahl aus.
Setzen Sie alle Vielfachen von 2 ab $2^2$ auf falsch (*).
Wenn das 3. Element des Arrays wahr ist, geben Sie 3 als Primzahl aus.
Setzen Sie alle Vielfachen von 3 ab $3^2$ auf falsch.
Wiederholen Sie den gleichen Vorgang für das 4., 5., …, und N-te Element.

Der Grund, warum die Elemente ab dem Quadrat des Wertes auf falsch gesetzt werden, liegt daran, dass Zahlen, die kleiner als das Quadrat sind, bereits in vorherigen Schritten verarbeitet wurden.

Implementierung in Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

Leicht optimierte Version

Wir können die Implementierung unter Berücksichtigung der folgenden Punkte leicht optimieren:

Initialisieren Sie das Array mit falsch (false) statt mit wahr (true) (das ist schneller).
Da Vielfache von 2 keine Primzahlen sind, überspringen Sie den Schritt, bei dem die Vielfachen von 2 auf falsch gesetzt werden.
Es ist nicht notwendig, bis n zu iterieren; es reicht aus, die Primzahlen bis zur Quadratwurzel von n zu berechnen, um alle Primzahlen zu finden, die kleiner oder gleich n sind.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

Referenz

Sieb des Eratosthenes (Wikipedia)

Wie man Diagramme mit Python (matplotlib.pyplot) zeichnet

Sun, 09 Apr 2023 01:02:19 +0900

Was Sie brauchen

Google-Konto

Schritte

Gehen Sie auf https://colab.research.google.com/
Wählen Sie “Datei” -> “Neues Notizbuch”
Fügen Sie den folgenden Code ein und führen Sie ihn aus

1
2
3
4
5
6
7


import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 500)
plt.plot(x, np.sin(x), label="sin curve")
plt.plot(x, np.cos(x), label="cos curve")
plt.legend() # Legende anzeigen
plt.show()

Ausführungsergebnis

Referenzen

matplotlib.pyplot — Matplotlib 3.5.3 documentation

Wie man KaTeX (LaTeX-ähnliche mathematische Formelanzeige) in hugo aktiviert

Fri, 31 Mar 2023 23:11:26 +0900

Was ist KaTeX

KaTeX ist eine JavaScript-Bibliothek zur Anzeige von mathematischen Formeln im LaTeX-Stil in HTML.

Konkret können Sie Formeln wie die folgende anzeigen.

$$f(x) = x^2 + x + 41$$

Es scheint auch andere LaTeX-ähnliche Formelanzeige-Bibliotheken zu geben, aber KaTeX ist dafür bekannt, einfach und schnell zu sein.

Wie man es in hugo integriert

Erstellen Sie ein neues layouts/partials/math.html in der Ordnerhierarchie von hugo.

Der Inhalt sollte wie folgt sein.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css" integrity="sha384-vKruj+a13U8yHIkAyGgK1J3ArTLzrFGBbBc0tDp4ad/EyewESeXE/Iv67Aj8gKZ0" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js" integrity="sha384-PwRUT/YqbnEjkZO0zZxNqcxACrXe+j766U2amXcgMg5457rve2Y7I6ZJSm2A0mS4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(
 document.body,
 {
 delimiters: [
 {left: "$$", right: "$$", display: true},
 {left: "\\[", right: "\\]", display: true},
 {left: "$", right: "$", display: false},
 {left: "\\(", right: "\\)", display: false}
 ]
 });
 });
</script>

Als Nächstes fügen Sie den folgenden Code zur vorhandenen Datei layouts/partials/extend_head.html hinzu.

1
2
3


{{ if or .Params.math .Site.Params.math }}
{{ partial "math.html" . }}
{{ end }}

Jetzt sind Sie bereit, KaTeX zu verwenden.

Sie können KaTeX aktivieren, indem Sie math: true in das Front Matter der Seite einfügen.

Alles, was noch zu tun ist, ist die Formel im LaTeX-Stil in den Textkörper des Seitenartikels zu schreiben.

1

$$ e^{i \pi} = -1 $$

Wenn Sie es wie oben schreiben, wird es wie unten angezeigt.

$$ e^{i \pi} = -1 $$

Referenz

Lösung des Problems des Handlungsreisenden mit Mathematica

Wed, 12 Oct 2022 19:05:58 +0900

Lösung des Problems des Handlungsreisenden mit Mathematica

Problem

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

Lösung

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

Erstellen Sie eine Matrix mit der Funktion SparseArray. Jedes Element repräsentiert die Entfernung zwischen den Städten in seiner Zeile und Spalte. Das erste Element {1,2}->10 bedeutet beispielsweise, dass die Entfernung zwischen 1 und 2 gleich 10 ist. Das vorletzte Element {9,9} gibt die Größe der Matrix an, und das letzte Element Infinity bedeutet, dass die Weglänge zwischen nicht angegebenen Städten unendlich ist, das heißt, es gibt keinen Weg.

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

Mit der Funktion FindShortestTour können Sie das Problem des Handlungsreisenden ganz einfach lösen. {1,2,3,4,5,6,7,8,9} repräsentiert die Stadtnummern. DistanceFunction->(d[[#1,#2]]&) übergibt die Matrix d, die die Entfernung zwischen den Städten darstellt.

Ausgabe

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

Die Ausgabe ist die kürzeste Entfernung und die Tourroute zu diesem Zeitpunkt. Die kürzeste Entfernung ist 137, und die Tourroute ist 1→2→5→9→8→7→6→3→4→1. Bei der Konvertierung in die alphabetische ABC-Reihenfolge wird es zu A, B, E, I, H, G, F, C, D.

Lieblings-Mathematikformeln

Wed, 05 Oct 2022 13:24:50 +0900

Satz von Wilson

Wenn $p$ eine Primzahl ist, gilt $(p−1)!≡−1 \pmod p$.

Eulersche Formel

$e^{iπ}+1=0$

Großer Fermatscher Satz

Für jede ganze Zahl $n≥3$ existieren keine positiven ganzen Zahlen $x,y,z$, die $x^n+y^n=z^n$ erfüllen.

Basler Problem

$1/1^2+1/2^2+1/3^2+1/4^2+...=π^2/6$

Eulersches primzahlerzeugendes Polynom

$n^2+n+41$ ergibt immer eine Primzahl, wenn $n$ eine ganze Zahl zwischen $0$ und $39$ ist.

【Vollständiges Verständnis durch Formeln】 Warum das stärkste klassische Verfahren GNFS von Quantenalgorithmen besiegt wird: Der Paradigmenwechsel der Primfaktorzerlegung

Mon, 01 Jan 0001 00:00:00 +0000

In der heutigen Internetgesellschaft wird die Informationssicherheit durch Public-Key-Kryptographie wie das RSA-Kryptosystem geschützt. Die Grundlage der Sicherheit des RSA-Kryptosystems beruht auf der Tatsache, dass „die Primfaktorzerlegung riesiger zusammengesetzter Zahlen rechnerisch extrem schwierig ist“ .

In diesem Artikel entschlüsseln wir den mathematischen Mechanismus des „Zahlkörpersiebs“ (General Number Field Sieve, GNFS), dem stärksten Algorithmus zur Primfaktorzerlegung für klassische Computer. Zugleich werden wir durch Formeln und Konzeptdiagramme detailliert ergründen, warum er durch den von Peter Shor entdeckten „Shor-Algorithmus“ vollständig besiegt wird und welchen Paradigmenwechsel dies darstellt.

1. Der Ansatz zur Primfaktorzerlegung in der klassischen Berechnung: Eine Entwicklung aus Fermats Faktorisierungsmethode

Das Problem der Primfaktorzerlegung besteht darin, für eine gegebene zusammengesetzte Zahl $N$ die Primzahlen $p, q$ zu finden, sodass $N = p \times q$ gilt.

Die grundlegende Idee läuft darauf hinaus, nicht-triviale Werte $x, y$ zu finden, die die folgende Kongruenz erfüllen:

$$ x^2 \equiv y^2 \pmod N $$

Durch Umformen erhalten wir:

$$ x^2 - y^2 \equiv 0 \pmod N $$ $$ (x - y)(x + y) \equiv 0 \pmod N $$

Wenn hier $x \not\equiv \pm y \pmod N$ gilt, können wir durch die Berechnung von $\gcd(x-y, N)$ oder $\gcd(x+y, N)$ einen nicht-trivialen Faktor von $N$ erhalten. Diese Tatsache bildet die Grundlage moderner Primfaktorzerlegungsalgorithmen wie dem GNFS.

2. Der stärkste klassische Algorithmus: Die Tiefen des „Zahlkörpersiebs“ (GNFS)

Das „GNFS“ ist der derzeit schnellste bekannte Algorithmus zur Primfaktorzerlegung für klassische Computer. Seine Zeitkomplexität erfordert eine subexponentielle (Sub-exponential) Zeit.

Die Zeitkomplexität von GNFS

Wenn die Anzahl der Ziffern der Zahl $N$ als $b = \log_2 N$ definiert ist, wird die Zeitkomplexität von GNFS wie folgt ausgedrückt:

$$ O\left( \exp \left( \left(\frac{64}{9} b\right)^{1/3} (\log b)^{2/3} \right) \right) $$

Wie aus dieser Formel ersichtlich ist, handelt es sich bei der Komplexität nicht um polynomielle Zeit, sondern um eine „subexponentielle Zeit“ , die nur geringfügig langsamer als exponentiell ist. Dennoch steigt die Berechnungszeit mit zunehmender Ziffernzahl astronomisch an.

Der mathematische Mechanismus von GNFS

GNFS besteht im Wesentlichen aus vier Schritten:

Polynomauswahl (Polynomial Selection)
Sieben (Sieving)
Matrixreduktion (Matrix Reduction)
Quadratwurzelberechnung (Square Root)

2.1. Polynomauswahl und algebraische Zahlkörper

Zunächst werden irreduzible Polynome $f(x)$ und $g(x)$ mit ganzzahligen Koeffizienten ausgewählt. Diese werden so festgelegt, dass sie modulo $N$ eine gemeinsame Wurzel $m$ haben. Das heißt:

$$ f(m) \equiv 0 \pmod N $$ $$ g(m) \equiv 0 \pmod N $$

Normalerweise wird $g(x)$ als lineares Polynom $g(x) = x - m$ gewählt. Setzt man die Wurzel von $f(x)$ als $\alpha$, so wird ein „algebraischer Zahlkörper“ (Number Field) namens $\mathbb{Q}(\alpha)$ konstruiert. Die Operationen im Ring von $\mathbb{Q}(\alpha)$ und die Operationen im normalen Ring der ganzen Zahlen $\mathbb{Z}$ werden über den Homomorphismus $\phi: \alpha \mapsto m$ verglichen.

2.2. Sieben (Sieving)

Als Nächstes wird massenhaft nach Paaren teilerfremder ganzer Zahlen $(a, b)$ gesucht. Das Ziel ist es, Paare zu finden, bei denen die folgenden zwei Werte jeweils „B-smooth“ sind (d. h. sie bestehen nur aus relativ kleinen Primfaktoren):

$a - bm$ (Wert über dem Ring der ganzen Zahlen)
$b^d f(a/b)$ (Entspricht der Norm $N(a - b\alpha)$ über dem algebraischen Zahlkörper)

Hierbei wird eine schnelle Suchmethode namens „Sieb“ (Sieve) angewendet. Dadurch werden $(a, b)$-Paare, die die Bedingungen erfüllen, effizient aus einer riesigen Menge von Kandidaten extrahiert.

2.3. Matrixreduktion (Linear Algebra over GF(2))

Aus den gesammelten $(a, b)$-Paaren werden Exponentenvektoren konstruiert, und der linke Nullraum einer riesigen, spärlich besetzten Matrix über $\mathbb{F}_2$ (einem Körper, der nur aus den Elementen 0 und 1 besteht) wird berechnet.

Man sucht als Lösung einen Vektor $v$, sodass die Relationen $ \prod (a_i - b_i m) $ und $ \prod (a_i - b_i \alpha) $ jeweils ein Quadrat werden. Dies ist nichts anderes als das Lösen eines linearen Gleichungssystems der Form:

$$ M \mathbf{x} \equiv \mathbf{0} \pmod 2 $$

Hierbei werden fortgeschrittene numerische Algorithmen wie das Block-Lanczos-Verfahren (Block Lanczos Algorithm) oder das Block-Wiedemann-Verfahren (Block Wiedemann Algorithm) eingesetzt.

2.4. Quadratwurzelberechnung

Schließlich wird sowohl im algebraischen Zahlkörper als auch im Ring der ganzen Zahlen die Quadratwurzel gezogen, um die Beziehung $x^2 \equiv y^2 \pmod N$ abzuleiten. Dann berechnet man $\gcd(x-y, N)$, um den Faktor zu erhalten.

3. Der Durchbruch durch Quantencomputing: Der „Shor-Algorithmus“

Während GNFS subexponentielle Zeit benötigt, kann der 1994 von Peter Shor veröffentlichte „Shor-Algorithmus“ dieses Problem mithilfe eines Quantencomputers in „polynomieller Zeit“ lösen.

Die Zeitkomplexität des Shor-Algorithmus

Wenn die Anzahl der Qubits $O(\log N)$ ist, ergibt sich die Zeitkomplexität wie folgt:

$$ O((\log N)^3) $$

Das bedeutet, dass es keine exponentielle Explosion relativ zur Anzahl der Bits gibt. Selbst bei gigantischen zusammengesetzten Zahlen, deren Berechnungszeit in der „klassischen Berechnung“ das Alter des Universums übersteigen würde, liefert die „Quantenberechnung“ das erstaunliche Ergebnis, dass sie in wenigen Stunden bis Tagen entschlüsselt werden können.

Das Gesamtbild des Shor-Algorithmus: Reduktion auf das Problem der Periodenfindung

Der Shor-Algorithmus reduziert das Problem der Primfaktorzerlegung geschickt auf das „Problem der Periodenfindung“ .

Wähle eine zufällige ganze Zahl $a$, die teilerfremd zu $N$ ist ($1 < a < N$).
Definiere die Funktion $f(x) = a^x \bmod N$.
Finde die Periode $r$ von $f(x)$, d. h. die kleinste positive ganze Zahl $r$, sodass $a^r \equiv 1 \pmod N$ gilt.
Wenn $r$ gerade ist, überprüfe, ob $a^{r/2} \not\equiv -1 \pmod N$ gilt, und berechne $\gcd(a^{r/2} \pm 1, N)$, um einen Primfaktor zu erhalten.

Das Finden der Periode $r$ in Schritt 3 ist genau der Flaschenhals, der in klassischen Computern exponentielle Zeit erfordert. Ein Quantencomputer löst dies jedoch durch die Anwendung von „Quantensuperposition“ und der „Quanten-Fourier-Transformation“ (QFT) in einem Augenblick.

4. Quanten-Fourier-Transformation (QFT) und Periodenextraktion

Betrachten wir den Kern des Shor-Algorithmus, die Manipulation von Quantenzuständen, anhand von Formeln genauer.

4.1. Erzeugung der Quantensuperposition

Zunächst werden zwei Quantenregister vorbereitet. Register 1 hält den Überlagerungszustand der Eingabe $x$, und Register 2 hält das Berechnungsergebnis der Funktion $f(x)$. Auf den Anfangszustand $|0\rangle |0\rangle$ wird die Hadamard-Transformation (Hadamard Transform) angewendet, um eine Superposition aller möglichen Werte für $x$ zu erzeugen.

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |0\rangle $$

(Hier ist $Q$ eine Zweierpotenz, die $N^2 \le Q < 2N^2$ erfüllt)

Als Nächstes wird mithilfe eines Quantenorakels $U_f$ der Wert $f(x) = a^x \bmod N$ berechnet und in Register 2 gespeichert.

$$ |\psi_2\rangle = U_f |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |a^x \bmod N\rangle $$

Nehmen wir an, wir würden hier Register 2 messen (die mathematische Struktur bleibt gleich, auch wenn wir nicht tatsächlich messen). Wenn ein bestimmter Wert $y = a^{x_0} \bmod N$ beobachtet wird, kollabiert der Zustand von Register 1 in eine Überlagerung aller $x$, für die $f(x) = y$ gilt. Wenn die Periode $r$ ist, sind solche Werte für $x$ gegeben durch $x_0, x_0 + r, x_0 + 2r, \dots$.

$$ |\psi_3\rangle = \frac{1}{\sqrt{M}} \sum_{k=0}^{M-1} |x_0 + kr\rangle $$

(Hierbei ist $M \approx Q/r$ die Anzahl der Terme)

Dieser Zustand beinhaltet die Information über die Periode $r$, aber eine direkte Messung würde nur ein zufälliges $x_0 + kr$ liefern, und die Periode $r$ bliebe unbekannt. Hier kommt die QFT ins Spiel.

4.2. Anwendung der Quanten-Fourier-Transformation (Quantum Fourier Transform)

Die QFT ist eine Operation, die eine diskrete Fourier-Transformation auf die Amplituden von Quantenzuständen durchführt. Die Wirkung der QFT auf den Zustand $|x\rangle$ ist wie folgt definiert:

$$ \text{QFT} |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} e^{2\pi i \frac{xy}{Q}} |y\rangle $$

Wenn man dies auf $|\psi_3\rangle$ anwendet, tritt Phaseninterferenz (Quanteninterferenz) auf.

$$ |\psi_4\rangle = \text{QFT} |\psi_3\rangle = \frac{1}{\sqrt{MQ}} \sum_{y=0}^{Q-1} \sum_{k=0}^{M-1} e^{2\pi i \frac{(x_0 + kr)y}{Q}} |y\rangle $$

Wenn man die Summe in dieser Formel erweitert,

$$ \sum_{k=0}^{M-1} e^{2\pi i \frac{kry}{Q}} $$

erscheint dieser Teil. Diese Summe einer geometrischen Reihe verstärkt sich nur dann gegenseitig (Constructive Interference), wenn $ry/Q$ nahe an einer ganzen Zahl liegt; andernfalls hebt sie sich auf (Destructive Interference).

Folglich ist der Zustand $|y\rangle$, der mit hoher Wahrscheinlichkeit gemessen wird, eine ganze Zahl $y$, die folgende Bedingung erfüllt:

$$ \frac{y}{Q} \approx \frac{c}{r} $$

($c$ ist hierbei irgendeine ganze Zahl).

4.3. Bestimmung der Periode durch Kettenbruchentwicklung

Nachdem man durch Messung $y$ erhalten hat, führt man mithilfe eines klassischen Computers eine „Kettenbruchentwicklung“ (Continued Fraction Expansion) von $y/Q$ durch. Dadurch kann man den Näherungsbruch $c/r$ von $y/Q$ berechnen und aus dem Nenner die Kandidaten für die Periode $r$ hocheffizient extrahieren.

5. Vergleich konzeptioneller Modelle und der Paradigmenwechsel

Um den Unterschied zwischen GNFS und dem Shor-Algorithmus intuitiv zu verstehen, zeigen wir im Folgenden ein Konzeptdiagramm in der Mermaid-Syntax.

Konzeptdiagramm des Shor-Algorithmus durch Quantenschaltkreise

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


graph TD
 A[Anfangszustand: 0...0] --> B[Superposition aller Zustände durch Hadamard-Transformation]
 B --> C[Modulare Exponentiation a^x mod N]
 C -->|Quantenverschränkung| D[Kollaps in einen Zustand mit Periodizität]
 D --> E[Quanten-Fourier-Transformation QFT]
 E -->|Wahrscheinlichkeitsverstärkung durch Interferenz| F[Messung: y erhalten]
 F --> G[Klassische Verarbeitung: Kettenbruchentwicklung]
 G --> H[Entdeckung der Periode r]
 H --> I[Berechnung der Primfaktoren von N]

 style A fill:#f9f,stroke:#333,stroke-width:2px
 style E fill:#bbf,stroke:#333,stroke-width:2px
 style I fill:#bfb,stroke:#333,stroke-width:2px

Das Wesen des Paradigmenwechsels

GNFS verfolgt den Ansatz, „in einem mathematischen Raum (algebraischen Zahlkörper) nach Relationen zu suchen“ . Da dieser Suchraum jedoch exponentiell mit der Anzahl der Ziffern wächst, wird die Entschlüsselung mit der Rechenleistung klassischer Computer (selbst bei Parallelisierung) faktisch unmöglich, wenn die Schlüssellänge 2048 Bit überschreitet.

Auf der anderen Seite nutzt der Shor-Algorithmus die „Welleneigenschaften durch Quanteninterferenz“ . Alle Berechnungswege in der Superposition werden gleichzeitig ausgewertet. Durch die QFT werden unnötige Antworten aufgehoben (destruktive Interferenz), und nur die Wahrscheinlichkeitsamplitude der korrekten Periode wird verstärkt (konstruktive Interferenz). Anstatt den Raum zu durchsuchen, wird so der völlig andere Ansatz realisiert, „die richtige Antwort selbst hervortreten zu lassen“ .

6. Zusammenfassung

In diesem Artikel haben wir das „GNFS“ , den Höhepunkt der klassischen Grenzen, und den „Shor-Algorithmus“ , der die Kraft des Quantencomputings demonstriert, hinsichtlich ihrer mathematischen Hintergründe und algorithmischen Strukturen tiefgehend verglichen.

Während GNFS durch mathematische Tricks wie die Polynomauswahl und riesige Matrixberechnungen die Zeitkomplexität auf subexponentielle Zeit reduzierte, gelang dem Shor-Algorithmus ein sofortiger Durchbruch in die polynomielle Zeit. Er verschmolz die Grundprinzipien der Quantenmechanik – Superposition und Interferenz – mit mathematischen Werkzeugen (QFT).

Derzeit gibt es keine fehlertoleranten Quantencomputer (FTQC), die den Shor-Algorithmus in einem praktischen Maßstab (Tausende von Qubits) ausführen können. Das bloße Vorhandensein dieses mathematischen und theoretischen Paradigmenwechsels ist jedoch der Hauptgrund, warum der Übergang zur Post-Quanten-Kryptographie (PQC: Post-Quantum Cryptography) derzeit weltweit dringend vorangetrieben wird.