Matematika on kenji.blog

【Pemahaman Lengkap dengan Rumus】 Mengapa "GNFS" Klasik Terkuat Dikalahkan oleh Algoritma Kuantum? Pergeseran Paradigma dalam Faktorisasi Prima

Sun, 06 Sep 2026 12:00:00 +0900

Keamanan informasi dalam masyarakat internet modern dilindungi oleh kriptografi kunci publik seperti kriptografi RSA. Dasar keamanan kriptografi RSA bergantung pada fakta bahwa “faktorisasi prima dari bilangan komposit yang sangat besar sangatlah sulit secara komputasi” .

Dalam artikel ini, kita akan mengungkap mekanisme matematis dari “General Number Field Sieve” (GNFS), algoritma faktorisasi prima terkuat untuk komputer klasik, dan mendalami mengapa algoritma ini sepenuhnya dikalahkan oleh “Algoritma Shor” yang ditemukan oleh Peter Shor. Kita akan mengeksplorasi pergeseran paradigma ini secara mendalam menggunakan rumus dan diagram konseptual.

1. Pendekatan Faktorisasi Prima dalam Komputasi Klasik: Perkembangan dari Metode Faktorisasi Fermat

Masalah faktorisasi prima adalah masalah untuk menemukan bilangan prima $p, q$ sedemikian rupa sehingga $N = p \times q$ untuk suatu bilangan komposit $N$ yang diberikan.

Ide dasarnya bermuara pada penemuan $x, y$ non-trivial yang memenuhi persamaan kongruensi berikut:

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

Jika kita memodifikasinya, kita mendapatkan:

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

Di sini, jika $x \not\equiv \pm y \pmod N$, kita dapat memperoleh faktor non-trivial dari $N$ dengan menghitung $\gcd(x-y, N)$ atau $\gcd(x+y, N)$. Fakta ini merupakan dasar dari algoritma faktorisasi modern seperti GNFS.

2. Algoritma Klasik Terkuat: Kedalaman dari “General Number Field Sieve” (GNFS)

“GNFS” adalah algoritma faktorisasi prima tercepat yang diketahui untuk komputer klasik saat ini. Kompleksitas waktunya membutuhkan waktu sub-eksponensial (Sub-exponential).

Kompleksitas GNFS

Jika kita asumsikan jumlah digit dari $N$ adalah $b = \log_2 N$, kompleksitas GNFS dapat dinyatakan sebagai berikut:

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

Seperti yang dapat dilihat dari rumus ini, kompleksitasnya bukanlah waktu polinomial, melainkan “waktu sub-eksponensial” yang sedikit lebih lambat dari eksponensial. Meskipun demikian, seiring dengan bertambahnya jumlah digit, waktu komputasi akan meningkat secara astronomis.

Mekanisme Matematis dari GNFS

GNFS sebagian besar terdiri dari 4 langkah:

Pemilihan Polinomial (Polynomial Selection)
Penyaringan (Sieving)
Pengurangan Matriks (Matrix Reduction)
Perhitungan Akar Kuadrat (Square Root)

2.1. Pemilihan Polinomial dan Medan Aljabar

Pertama, pilih polinomial tak tereduksi $f(x)$ dan $g(x)$ dengan koefisien bilangan bulat. Keduanya diatur untuk memiliki akar persekutuan $m$ modulo $N$. Yaitu:

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

Biasanya, $g(x)$ dipilih sebagai polinomial derajat pertama $g(x) = x - m$. Jika akar dari $f(x)$ adalah $\alpha$, maka “Medan Aljabar” (Number Field) $\mathbb{Q}(\alpha)$ akan dibentuk. Kita membandingkan operasi dalam gelanggang $\mathbb{Q}(\alpha)$ dan operasi dalam gelanggang bilangan bulat biasa $\mathbb{Z}$ melalui homomorfisme $\phi: \alpha \mapsto m$.

2.2. Penyaringan (Sieving)

Selanjutnya, kita mencari sejumlah besar pasangan bilangan bulat koprima $(a, b)$. Tujuannya adalah untuk menemukan pasangan sedemikian rupa sehingga kedua nilai berikut adalah “B-smooth” (hanya terdiri dari faktor prima yang relatif kecil):

$a - bm$ (nilai pada gelanggang bilangan bulat)
$b^d f(a/b)$ (sesuai dengan norma $N(a - b\alpha)$ pada medan aljabar)

Di sini, teknik pencarian cepat yang disebut “Saringan” (Sieve) digunakan. Hal ini memungkinkan ekstraksi pasangan $(a, b)$ yang memenuhi kondisi dari kandidat dalam jumlah yang sangat besar secara efisien.

2.3. Pengurangan Matriks (Linear Algebra over GF(2))

Dari pasangan $(a, b)$ yang dikumpulkan, kita membentuk vektor eksponen dan mencari ruang nol kiri dari matriks renggang (sparse matrix) besar pada $\mathbb{F}_2$ (medan dengan elemen hanya 0 dan 1).

Kita mencari solusi vektor $v$ sehingga relasi $ \prod (a_i - b_i m) $ dan $ \prod (a_i - b_i \alpha) $ masing-masing menjadi elemen kuadrat sempurna. Hal ini tidak lain adalah menyelesaikan sistem persamaan linear:

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

Di sini, algoritma komputasi numerik tingkat lanjut seperti Block Lanczos Algorithm atau Block Wiedemann Algorithm dimanfaatkan.

2.4. Perhitungan Akar Kuadrat

Terakhir, kita mengambil akar kuadrat dari medan aljabar dan gelanggang bilangan bulat, yang menghasilkan relasi $x^2 \equiv y^2 \pmod N$. Kemudian, kita menghitung $\gcd(x-y, N)$ dan memperoleh faktornya.

3. Terobosan Komputasi Kuantum: “Algoritma Shor”

Berbeda dengan GNFS yang membutuhkan waktu sub-eksponensial, “Algoritma Shor” yang diterbitkan oleh Peter Shor pada tahun 1994, dapat memecahkan masalah ini dalam “waktu polinomial” dengan menggunakan komputer kuantum.

Kompleksitas Algoritma Shor

Jika kita mengasumsikan jumlah qubit sebagai $O(\log N)$, maka kompleksitas waktunya adalah:

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

Ini berarti tidak terjadi ledakan eksponensial sehubungan dengan jumlah bit. Ini adalah hasil yang menakjubkan di mana bilangan komposit sangat besar yang waktu komputasi “komputasi klasik” -nya melebihi umur alam semesta, dapat dipecahkan dalam hitungan jam hingga hari menggunakan “komputasi kuantum” .

Gambaran Umum Algoritma Shor: Reduksi ke Masalah Pencarian Periode

Algoritma Shor dengan cerdik mereduksi masalah faktorisasi prima menjadi “masalah pencarian periode” .

Pilih bilangan bulat acak $a$ yang relatif prima dengan $N$ ($1 < a < N$).
Definisikan fungsi $f(x) = a^x \bmod N$.
Temukan periode $r$ dari $f(x)$, yaitu bilangan bulat positif terkecil $r$ sedemikian rupa sehingga $a^r \equiv 1 \pmod N$.
Jika $r$ bernilai genap, periksa apakah $a^{r/2} \not\equiv -1 \pmod N$, lalu hitung $\gcd(a^{r/2} \pm 1, N)$ untuk mendapatkan faktor prima.

Langkah ke-3, yaitu “penemuan periode $r$” , adalah hambatan yang memerlukan waktu eksponensial pada komputer klasik. Namun, komputer kuantum memecahkan masalah ini dalam sekejap menggunakan “Superposisi Kuantum” dan “Transformasi Fourier Kuantum” (QFT).

4. Transformasi Fourier Kuantum (QFT) dan Ekstraksi Periode

Mari kita lihat lebih dekat operasi matematis keadaan kuantum yang menjadi inti dari Algoritma Shor.

4.1. Generasi Superposisi Kuantum

Pertama, siapkan 2 register kuantum. Register 1 menahan keadaan superposisi input $x$, dan Register 2 menahan hasil komputasi fungsi $f(x)$. Terapkan Transformasi Hadamard (Hadamard Transform) ke keadaan awal $|0\rangle |0\rangle$ untuk menciptakan superposisi semua kemungkinan $x$.

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

(Di mana $Q$ adalah pangkat 2 yang memenuhi $N^2 \le Q < 2N^2$)

Selanjutnya, gunakan orakel kuantum $U_f$ untuk menghitung $f(x) = a^x \bmod N$ dan menyimpannya di register 2.

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

Sekarang asumsikan register 2 diukur (secara teoritis, meskipun tidak diukur, struktur matematisnya tetap sama). Jika suatu nilai $y = a^{x_0} \bmod N$ diamati, keadaan register 1 akan runtuh (collapse) ke superposisi semua $x$ yang memenuhi $f(x) = y$. Misalkan periodenya adalah $r$, maka $x$ tersebut adalah $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 $$

(Di mana $M \approx Q/r$ adalah jumlah suku)

Keadaan ini mengandung informasi periode $r$, namun pengukuran langsung hanya akan menghasilkan $x_0 + kr$ acak, dan periode $r$ tetap tidak diketahui. Di sinilah QFT berperan.

4.2. Penerapan Transformasi Fourier Kuantum (QFT)

QFT adalah operasi yang menerapkan transformasi Fourier diskrit ke amplitudo keadaan kuantum. Aksi QFT pada keadaan $|x\rangle$ didefinisikan sebagai berikut:

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

Bila ini diterapkan pada $|\psi_3\rangle$, interferensi fase (interferensi kuantum) akan terjadi.

$$ |\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 $$

Jika kita memperluas penjumlahan dari rumus ini, bagian berikut muncul:

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

Penjumlahan deret geometri ini akan saling menguatkan (Constructive Interference) hanya ketika $ry/Q$ mendekati bilangan bulat, dan akan saling meniadakan (Destructive Interference) pada titik lainnya.

Oleh karena itu, keadaan $|y\rangle$ yang diukur dengan probabilitas tinggi akan berupa bilangan bulat $y$ yang memenuhi:

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

(Di mana $c$ adalah suatu bilangan bulat).

4.3. Identifikasi Periode melalui Ekspansi Pecahan Berlanjut

Setelah memperoleh $y$ melalui pengukuran, gunakan komputer klasik untuk melakukan “Ekspansi Pecahan Berlanjut” (Continued Fraction Expansion) pada $y/Q$. Hal ini memungkinkan penghitungan pecahan hampiran $c/r$ dari $y/Q$ dan mengekstrak kandidat periode $r$ dari penyebut secara sangat efisien.

5. Perbandingan Model Konseptual dan Pergeseran Paradigma

Untuk memahami secara intuitif perbedaan antara GNFS dan Algoritma Shor, diagram konseptual ditunjukkan menggunakan notasi Mermaid.

Diagram Konseptual Algoritma Shor dengan Sirkuit Kuantum

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


graph TD
 A[Keadaan Awal: 0...0] --> B[Superposisi semua keadaan dengan Transformasi Hadamard]
 B --> C[Operasi Pangkat Modular a^x mod N]
 C -->|Keterikatan Kuantum| D[Runtuh ke keadaan dengan periodisitas]
 D --> E[Transformasi Fourier Kuantum QFT]
 E -->|Amplifikasi probabilitas via interferensi| F[Pengukuran: Mendapatkan y]
 F --> G[Pemrosesan Klasik: Ekspansi Pecahan Berlanjut]
 G --> H[Penemuan Periode r]
 H --> I[Menghitung Faktor Prima dari 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

Intisari Pergeseran Paradigma

GNFS menggunakan pendekatan “mencari relasi di dalam ruang matematis (medan aljabar)” . Namun, karena ruang pencarian meluas secara eksponensial sehubungan dengan jumlah digit, dekripsi pada dasarnya menjadi mustahil untuk panjang kunci melebihi 2048 bit menggunakan kemampuan komputasi klasik (bahkan dengan paralelisasi).

Di sisi lain, Algoritma Shor memanfaatkan “sifat gelombang dari interferensi kuantum” . Algoritma ini mengevaluasi semua jalur komputasi dalam keadaan superposisi secara simultan, saling meniadakan (melemahkan) jawaban yang tidak perlu menggunakan QFT, dan hanya menguatkan amplitudo probabilitas dari periode yang benar. Dengan ini, pendekatan tersebut tidak lagi mencari di dalam ruang, melainkan mengadopsi dimensi yang sama sekali berbeda: “membuat jawaban yang benar muncul ke permukaan” .

6. Kesimpulan

Dalam artikel ini, kami telah membandingkan secara mendalam latar belakang matematis dan struktur algoritma antara “GNFS” yang merupakan batas ekstrem komputasi klasik, dengan “Algoritma Shor” yang memamerkan kekuatan komputasi kuantum.

Sementara GNFS menggunakan keahlian matematis seperti pemilihan polinomial dan komputasi matriks besar untuk menekan kompleksitas ke waktu sub-eksponensial, Algoritma Shor berhasil mencapai terobosan langsung ke waktu polinomial dengan menggabungkan prinsip dasar mekanika kuantum, yakni superposisi dan interferensi, dengan alat matematis (QFT).

Saat ini, belum ada Komputer Kuantum Toleran Kesalahan (FTQC) berskala praktis (ribuan qubit) yang mampu menjalankan Algoritma Shor. Namun, keberadaan pergeseran paradigma teoritis dan matematis inilah yang menjadi alasan utama mengapa transisi ke Kriptografi Pasca-Kuantum (PQC: Post-Quantum Cryptography) dipercepat secara global di seluruh dunia saat ini.

[Bedah Lengkap] Memahami Algoritma Kriptanalisis Terkuat "GNFS" dengan Mengimplementasikannya di C++

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

[Bedah Lengkap] Memahami Algoritma Kriptanalisis Terkuat “GNFS” dengan Mengimplementasikannya di C++

“Kriptografi RSA” mendukung dasar dari internet modern. Kekuatannya bergantung pada keyakinan matematis bahwa “memfaktorkan bilangan komposit yang sangat besar menjadi faktor prima secara praktis tidak mungkin dilakukan oleh komputer saat ini”.

Namun, umat manusia tidak pernah menyerah. Saat ini, terdapat ** algoritma terkuat dan paling canggih buatan manusia ** untuk faktorisasi prima besar pada komputer klasik (komputer biasa, bukan komputer kuantum). Ini disebut ** “General Number Field Sieve (GNFS)” **.

Dalam artikel ini, kami akan merilis secara lengkap kode implementasi C++ (menggunakan integer presisi ganda boost::multiprecision dari pustaka Boost) yang memodelkan secara ketat logika komputasi canggih dari GNFS ini. Kami juga akan menjelaskan secara mendalam tentang “teori bilangan aljabar” di baliknya.

Silakan nikmati misteri matematika dan kekuatan ilmu komputer yang menaklukkannya bersama dengan kode sumbernya.

1. Kerangka Logika Canggih GNFS (Kode Sumber Lengkap)

Pertama, mari kita lihat gambaran keseluruhan implementasi GNFS C++ yang akan kita bahas kali ini. Sistem Number Field Sieve yang sebenarnya (seperti CADO-NFS) adalah sistem terdistribusi raksasa dengan ratusan ribu baris kode. Namun, kode ini dirancang dengan mengekstrak ** “5 alur (fase) esensial” ** yang membentuk GNFS menjadi kelas-kelas, memodelkannya dalam konfigurasi minimal tanpa kehilangan makna matematisnya.

 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>

// Menggunakan integer presisi ganda Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve Kerangka Logika Tercanggih
//
// Kode ini secara ketat memodelkan 5 alur dari GNFS canggih
// yang digunakan dalam CADO-NFS dll., sebagai desain kelas C++ (Boost).
// ============================================================================

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

// ============================================================================
// Fase 1: Pemilihan Polinomial (Algoritma KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinomial sisi aljabar f(x)
 std::vector<cpp_int> g; // Polinomial sisi rasional g(x) = x - m
 cpp_int m;

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

 // Pembuatan polinomial awal berdasarkan ekspansi basis-m (pada kenyataannya menggunakan reduksi basis kisi LLL yang lebih canggih)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Pemilihan Polinomial (Derajat " << degree << ") dimulai..." << std::endl;
 // Ekspansi basis-m sederhana (derajat d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Perkiraan m yang sederhana (perkiraan tanpa menggunakan fungsi Boost)
 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[Fase 1] Selesai." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Penyaringan Kisi)
// ============================================================================
// GNFS modern tidak menggunakan Line Sieve (Penyaringan Garis), tetapi
// menggunakan Special-q Lattice Sieving oleh Franke-Kleinjung sebagai standar de facto.
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 << "[Fase 2] Membuat Basis Faktor (Batas Rasional: " << rational_bound << ", Batas Aljabar: " << algebraic_bound << ")" << std::endl;
 // (Dihilangkan) Pada kenyataannya, pembuatan bilangan prima dan pemfilteran dengan simbol Legendre dilakukan
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving aktif..." << std::endl;
 std::vector<Relation> relations;
 // Implementasi tiruan: Saringan kisi sebenarnya memindai ruang memori ratusan GB dalam blok
 // (a, b) pasangan dipetakan ke kisi (a = i*q + j*...) untuk setiap prima khusus q,
 // dan saringan yang memaksimalkan efisiensi cache dijalankan.

 // Menambahkan satu relasi tiruan untuk demo
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Fase 2] Ditemukan " << relations.size() << " relasi." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Pembersihan Singleton dan Penggabungan Clique)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Menyaring Relasi..." << std::endl;
 // 1. Penghapusan singleton (menghapus relasi dengan prima yang muncul hanya sekali)
 // 2. Penggabungan clique (menggabungkan relasi untuk mengubah matriks jarang menjadi padat)
 // Pada kenyataannya, algoritma seperti Union-Find digunakan untuk mengompres matriks ratusan juta baris menjadi beberapa juta baris.
 std::cout << "[Fase 3] Ukuran matriks dikurangi secara optimal." << std::endl;
 }
};

// ============================================================================
// Fase 4: Aljabar Linier di atas GF(2) (Metode Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // Dalam lingkungan superkomputer modern, daripada metode Block Lanczos,
 // metode Block Wiedemann (Implementasi Coppersmith) yang cocok untuk komputasi terdistribusi digunakan sebagai teknologi mutakhir.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritma Block Wiedemann di atas GF(2) dimulai..." << std::endl;
 // Mengulangi operasi produk antara matriks jarang (sparse) dan vektor,
 // menemukan beberapa vektor solusi (kernel) yang memenuhi M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Daftar dependensi
 // Data tiruan
 dependencies.push_back({0});

 std::cout << "[Fase 4] Ditemukan " << dependencies.size() << " dependensi linier (kuadrat sempurna)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Akar Kuadrat Aljabar (Algebraic Square Root)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Fase 5] Komputasi Akar Kuadrat Aljabar..." << std::endl;

 // 1. Komputasi akar kuadrat V dari sisi rasional (operasi bilangan bulat sederhana)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Komputasi akar kuadrat gamma dari sisi aljabar (Metode Montgomery, dll.)
 // Menemukan elemen gamma dari field aljabar besar O_K dan memetakannya ke dunia nyata dengan homomorfisme phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Diasumsikan bahwa barisan Karakter Kuadrat (Quadratic Characters) telah ditambahkan di Fase 2 dan 4
 // untuk menghindari hambatan (Obstruction) dari grup kelas ideal dan grup unit.

 std::cout << " -> Peta homomorfisme phi diterapkan." << std::endl;
 std::cout << "[Fase 5] Menghitung FPB(V - Y, N)..." << std::endl;

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

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUKSES] Faktor non-trivial ditemukan: " << factor << std::endl;
 std::cout << " Faktor lain: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[GAGAL] Solusi trivial. Mencoba dependensi berikutnya..." << std::endl;
 }
 }
};

// ============================================================================
// Alur Eksekusi Utama
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Mesin General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Bilangan komposit raksasa N yang ingin difaktorkan, seperti RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Derajat polinomial (untuk lebih dari 130 digit, biasanya dipilih derajat 5 hingga 6)
 int degree = 6;

 // Inisialisasi alur
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Batas sebenarnya adalah puluhan hingga ratusan juta
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. Pemilihan polinomial
 poly_select.select(N);

 // 2. Proses penyaringan (sieve)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Penyaringan (kompresi matriks)
 filter.reduce_matrix(relations);

 // 4. Aljabar linier (Pencarian ruang nol di atas GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Perhitungan akar kuadrat aljabar dan FPB
 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[Sistem] Alur SOTA GNFS selesai dalam " << elapsed.count() << " detik." << std::endl;

 return 0;
}

Lalu, bagaimana kode ini bekerja menghancurkan dinding kriptografi? Kita akan memecah dan menjelaskan algoritma yang cermat dan matematika lanjutan untuk setiap 5 fase.

2. Tujuan Akhir GNFS: $X^2 \equiv Y^2 \pmod N$

Tidak hanya GNFS, tujuan dari sebagian besar algoritma faktorisasi prima raksasa modern adalah menemukan pasangan non-trivial $(X, Y)$ yang memenuhi persamaan kongruensi berikut:

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

Persamaan ini berarti “sisa pembagian $X^2$ dan $Y^2$ oleh $N$ adalah sama”. Jika kita mengubah ini, $X^2 - Y^2 \equiv 0 \pmod N$ Dengan kata lain, $(X-Y)(X+Y)$ adalah kelipatan $N$.

Jika $X \not\equiv \pm Y \pmod N$ (solusi non-trivial), maka akan ada “pembagi persekutuan yang lebih besar dari 1 dan lebih kecil dari $N$” antara $(X-Y)$ dan $N$. Di sini, jika kita menggunakan Algoritma Euclidean untuk menghitung ** $\gcd(X-Y, N)$ **, kita dapat dengan mudah menemukan faktor prima dari $N$.

Namun, menemukan $X$ dan $Y$ ini seperti mencari jarum di padang pasir. Oleh karena itu, GNFS mengambil pendekatan jenius dengan mendistribusikan komputasi dengan menciptakan ** dua dunia **: “dunia bilangan bulat nyata” dan “dunia field aljabar polinomial”.

3. Fase 1: Pemilihan Polinomial (Polynomial Selection)

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


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

Langkah pertama GNFS adalah membuat “polinomial ajaib” untuk menjembatani dua dunia tersebut. Untuk bilangan $N$ yang sangat besar, kita memilih bilangan bulat $m$. Biasanya kita memilih agar $m \approx N^{1/d}$ (dalam kode, kita mengasumsikan polinomial derajat $d=6$).

Kemudian, $N$ diekspansi ke basis $m$, dan polinomial $f(x)$ dibangun menggunakan koefisien tersebut:

$$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$$

Polinomial $f(x)$ ini memiliki sifat yang sangat penting yaitu ** “jika kita menyubstitusikan $m$ ke variabel $x$, nilainya tepat $N$ ($f(m) = N$)” **. Dengan kata lain, $f(m) \equiv 0 \pmod N$. Polinomial sisi rasional didefinisikan sebagai $g(x) = x - m$.

Sebagai hasilnya, ** “dunia field aljabar $\mathbb{Z}[\alpha]$” ** yang diatur oleh akar $\alpha$ dari $f(x)=0$ dan ** “dunia rasional (bilangan bulat) $\mathbb{Z}$” ** biasa akan terikat kuat oleh “Homomorfisme Ring” $x \to m$.

Dalam CADO-NFS termutakhir dan lainnya, algoritma KleinJung dan algoritma reduksi basis kisi LLL digunakan untuk mencari “polinomial terbaik $f(x)$” di mana koefisien polinomial tidak menjadi terlalu besar, dan bilangan prima cenderung muncul (mudah menjadi mulus) pada langkah selanjutnya, yang memakan waktu pencarian berbulan-bulan.

4. Fase 2: Special-q Lattice Sieving (Penyaringan Kisi q-Khusus)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Pasangan (a, b) dipetakan ke kisi untuk setiap bilangan prima khusus q,
 // dan saringan (sieve) yang memaksimalkan efisiensi cache dijalankan.
 // ...
 }
};

Setelah kedua dunia disiapkan, langkah selanjutnya adalah mencari “bilangan mulus (smooth number - bilangan yang hanya terdiri dari faktor prima kecil)” di kedua dunia tersebut. Jumlah pasangan integer $(a, b)$ yang tak terhingga dihasilkan, dan dua nilai berikut dihitung:

Nilai sisi rasional : $a - bm$
Norma sisi aljabar : $b^d f(a/b)$

Tujuan GNFS adalah mengumpulkan puluhan hingga ratusan juta dari ** “pasangan di mana baik nilai sisi rasional maupun aljabar dapat diuraikan sepenuhnya hanya menggunakan faktor prima kecil (Relasi)” **.

Pada GNFS awal, digunakan “Line Sieve”, di mana pasangan $(a, b)$ disusun pada bidang $xy$ dan dibagi dengan bilangan prima secara berurutan. Namun, metode ini sangat lambat karena menyebabkan banyak cache miss saat mengakses memori.

Oleh karena itu, kode modern tercanggih menggunakan metode yang disebut ** “Special-q Lattice Sieve” **. Sebuah bilangan prima sedang yang cukup besar $q$ ditetapkan, dan hanya pasangan $(a, b)$ di mana “nilai sisi aljabar pasti habis dibagi $q$” yang dihitung. Pasangan $(a, b)$ yang memenuhi kondisi ini membentuk “Lattice (Kisi)” di bidang, membuat lompatan alamat yang dihitung konstan, dan sangat pas di cache L1/L2 CPU. Pengenalan penyaringan kisi ini sangat meningkatkan kecepatan perhitungan GNFS.

5. Fase 3: Filtering (Penyaringan)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Penghapusan Singleton (menghapus relasi dengan prima yang muncul hanya 1 kali)
 // 2. Penggabungan Clique (menggabungkan relasi untuk memadatkan matriks yang jarang)
 }
};

Ratusan juta relasi yang dikumpulkan oleh komputer di seluruh dunia selama beberapa bulan pada Fase 2. Namun, jika kita memasukkannya langsung ke “langkah memecahkan sistem persamaan (perhitungan matriks)” berikutnya, memori superkomputer akan penuh sesak.

Oleh karena itu, proses kompresi ekstrem dari matriks yang disebut ** Filtering ** dilakukan.

Penghapusan Singleton (Pembersihan Singularitas) Misalkan sebuah bilangan prima besar $p$ muncul “hanya 1 kali” dari ratusan juta relasi. Tujuan kita adalah “membuat pangkat semua bilangan prima genap (kelipatan 2)”, jadi bilangan prima yang hanya muncul 1 kali tidak akan pernah genap. Oleh karena itu, relasi yang mengandung prima tersebut langsung dihapus (dibersihkan) sebagai “sampah yang tidak berguna”. Karena hal ini terjadi berantai, ratusan juta baris data akan dipangkas.
Penggabungan Clique (Clique Merging) Selanjutnya, dengan mengalikan (menambahkan) relasi yang berbagi bilangan prima tertentu, matriks yang jarang (sparse) dipadatkan (dikompres) sementara jumlah baris dikurangi (mirip dengan pencarian clique di teori graf).

Melalui pengoptimalan ini, matriks sparse raksasa dikompresi secara dramatis menjadi ukuran yang dapat dihitung.

6. Fase 4: Aljabar Linier atas GF(2) (Metode Block Wiedemann)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Mengulangi perhitungan produk matriks jarang dan vektor,
 // dan menemukan beberapa vektor solusi (kernel) untuk M * x = 0 mod 2.
 }
};

Kini kita tiba di inti teka-teki. Kita mengalikan relasi yang terkumpul untuk mencari ** “kombinasi di mana pangkat semua faktor prima menjadi genap” **.

Secara matematis, menggunakan matriks raksasa $M$ yang elemen-elemennya mewakili “genap atau ganjil (yaitu 0 atau 1)” dari pangkat setiap prima, dan vektor $x$ yang merepresentasikan relasi mana yang digunakan, kita perlu menyelesaikan vektor $x$ (Null space / Kernel) sehingga: $M \cdot x \equiv 0 \pmod 2$

Kita harus memecahkan sistem persamaan sebuah matriks sebesar jutaan baris × jutaan kolom. Eliminasi Gauss konvensional membutuhkan kompleksitas $O(N^3)$, yang berarti perhitungannya takkan selesai hingga alam semesta berakhir.

Oleh karena itu, implementasi termutakhir menggunakan ** “Metode Block Wiedemann” **. Ini adalah jenis metode subruang Krylov yang menemukan solusi melalui iterasi perkalian matriks-vektor, memanfaatkan fakta bahwa matriks $M$ sangat “sparse (sebagian besar 0)”. Tidak seperti metode Block Lanczos yang lama, Block Wiedemann secara penuh membagi proses komputasi ke dalam berbagai cluster, menunjukkan kekuatan besar dalam komputasi awan terdistribusi modern maupun superkomputer.

7. Fase 5: Algebraic Square Root (Akar Kuadrat Aljabar) dan Kehancuran Kriptografi

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Perhitungan akar kuadrat V dari sisi rasional
 cpp_int V = 1;

 // 2. Perhitungan akar kuadrat gamma dari sisi aljabar
 cpp_int Y = 1;

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

Melalui perhitungan matriks di Fase 4, kita mendapatkan himpunan relasi $S$ yang “jika dikalikan, semua faktor primanya akan berpangkat genap”. Dengan ini, kita dapat menyusun “kuadrat” pada masing-masing dunia rasional dan aljabar.

Karena sisi rasional hanyalah perkalian bilangan bulat, akar kuadrat $V$ mudah dihitung.

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

Namun, neraka sesungguhnya terletak di “sisi aljabar”. Di dunia field aljabar $\mathbb{Z}[\alpha]$, keunikan faktorisasi prima tidak berlaku, maka komputasi dilakukan menggunakan ideal. Perhitungan matriks hanya memastikan itu ** “menjadi kuadrat sebuah ideal”, tetapi tidak “menjamin bahwa ia merupakan kuadrat dari sebuah elemen ($\gamma^2$)” **.

Di sinilah hambatan (Obstruction) kuat teori bilangan aljabar menghalangi, yang disebut “Hambatan Grup Kelas Ideal” dan “Hambatan Grup Unit”. GNFS menembus dinding ini dengan menggunakan keajaiban yang disebut ** “Karakter Kuadrat (Quadratic Characters)” **. Ke dalam matriks Fase 4, kita diam-diam menambahkan beberapa kolom residu kuadrat (Simbol Legendre) untuk beberapa puluh ideal prima khusus sebelumnya. Berkat hal ini, himpunan $S$ yang ditemukan akan lolos dari hambatan dengan probabilitas sangat tinggi, dan berhasil membentuk “kuadrat elemen sejati $\gamma^2$”.

Tugas menemukan $\gamma$ (Akar Kuadrat Aljabar) dihitung dengan menggunakan algoritma yang sangat kompleks seperti Metode Montgomery.

Dan pada akhirnya, akar kuadrat aljabar $\gamma$ di-warp ke dunia nyata oleh homomorfisme ring $\phi$ (mensubstitusikan $m$ ke $x$), untuk memperoleh $Y$. Dengan menetapkan $V$ di sisi rasional sebagai $X$, maka persamaan mutlak yang kita cari pun sempurna terbentuk.

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

Yang tersisa hanyalah menghitung $\gcd(X-Y, N)$. Hanya dalam 0,001 detik, ketika faktor non-trivial tercetak di layar, Kriptografi RSA yang dianggap tak tergoyahkan hancur sepenuhnya.

Kesimpulan

GNFS bukan sekadar teknik pemrograman. Ini adalah mahakarya intelijen umat manusia yang menaklukkan “kedalaman matematika murni” seperti aljabar abstrak, teori ring, dan grup kelas ideal menggunakan “teknik tingkat tinggi” seperti arsitektur terdistribusi superkomputer dan optimasi cache.

Informasi chat atau kartu kredit kita yang biasa kita kirim setiap hari, ternyata dilindungi oleh pertempuran matematis yang sangat besar seperti ini.

Kami berharap melalui kerangka C++ ini, Anda bisa merasakan “romantisme matematika dan komputer” di balik algoritma pemecahan kode yang mutakhir.

Struktur Matematis Sejati dari General Number Field Sieve (GNFS)

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

Struktur Matematis Sejati dari General Number Field Sieve (GNFS)

Tujuan akhir dari GNFS adalah menemukan $X, Y$ sedemikian rupa sehingga $X^2 \equiv Y^2 \pmod N$. Untuk mencapai ini, para matematikawan membangun sebuah jembatan antara “dunia bilangan bulat nyata” dan “dunia medan aljabar”. Jembatan tersebut adalah “homomorfisme”.

Tahap 1: “Homomorfisme” (Homomorphism) yang Menghubungkan Dunia

1. Pemilihan Polinomial dan Definisi Akar

Untuk sebuah bilangan komposit raksasa $N$, kita memilih sebuah bilangan bulat $m$ dan polinomial $f(x)$ sedemikian rupa sehingga $f(m) \equiv 0 \pmod N$. (Contoh: Ekspansi $N$ dalam basis $m$, dan buat $f(x)$ dari koefisien-koefisiennya. Dalam hal ini, $f(x)$ diasumsikan tak tereduksi di atas medan bilangan rasional $\mathbb{Q}$).

Selanjutnya, misalkan $\alpha$ adalah salah satu “akar bilangan kompleks” dari persamaan $f(x) = 0$. Tentu saja, $f(\alpha) = 0$. $\alpha$ bukanlah bilangan bulat, melainkan bilangan kompleks (bilangan aljabar) yang dapat memuat akar atau bilangan imajiner.

2. Konstruksi Cincin (Ring) dan Homomorfisme

Di sini, kita menyiapkan dua “cincin” matematis (dunia di mana penjumlahan dan perkalian didefinisikan):

Dunia A: $\mathbb{Z}[\alpha]$ (Cincin bilangan bulat aljabar yang mengandung $\alpha$) Ini adalah dunia bilangan yang diekspresikan dalam bentuk $a + b\alpha + c\alpha^2 + \dots$.
Dunia B: $\mathbb{Z}/N\mathbb{Z}$ (Cincin sisa pembagian dengan $N$) Dunia kongruensi (modulo) yang hanya terdiri dari bilangan bulat dari $0$ hingga $N-1$.

Di sini, kita mendefinisikan sebuah pemetaan (mapping) $\phi$ dari Dunia A ke Dunia B sebagai berikut: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Pemetaan $\phi$ ini adalah operasi magis yang sepenuhnya menukar variabel $\alpha$ di Dunia A dengan bilangan bulat $m$ di Dunia B. $\phi$ ini memiliki sifat yang sangat kuat yang disebut “Homomorfisme Cincin” (Ring Homomorphism). Homomorfisme adalah sifat “berpindah ke dunia lain tanpa merusak struktur penjumlahan dan perkalian”. Artinya, persamaan berikut berlaku:

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

Apa arti semua ini? Jika kita dapat membuat “bentuk kuadrat” ($\gamma^2$) dari elemen kompleks $\gamma$ di “Dunia A” (dunia $\alpha$), kita dapat melompat ke “Dunia B” (dunia sisa) dengan $\phi$, dan bentuk kuadrat $\phi(\gamma)^2$ akan dipertahankan dengan sempurna.

Tahap 2: Runtuhnya Faktorisasi Prima dan Lahirnya “Ideal”

Kita ingin mengumpulkan banyak elemen $(a - b\alpha)$ yang sesuai dalam Dunia A ($\mathbb{Z}[\alpha]$) dan mengalikannya bersama untuk membuat “kuadrat sempurna” (elemen kuadrat). Biasanya, kita dapat melakukan “faktorisasi prima” pada $(a - b\alpha)$ yang dikumpulkan, dan menggabungkannya sehingga semua pangkat bilangan prima menjadi genap (dipecahkan menggunakan matriks) untuk menghasilkan bentuk kuadrat.

Namun, di sinilah tembok keputusasaan aljabar menghalangi jalan. Di dunia medan aljabar seperti $\mathbb{Z}[\alpha]$, “keunikan faktorisasi prima (setiap bilangan dapat dinyatakan hanya dengan satu cara sebagai perkalian bilangan prima)” yang kita pelajari di sekolah menengah runtuh sama sekali.

(Contoh: Di beberapa dunia medan aljabar, $6 = 2 \times 3$, dan pada saat yang sama $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, sehingga mustahil untuk mengetahui mana yang merupakan bilangan prima sejati).

Jika faktorisasi prima tidak unik, teka-teki “menghitung bilangan prima hingga jumlahnya genap” (metode saringan) pada prinsipnya tidak dapat dijalankan.

Keselamatan dari Kummer dan Dedekind: “Ideal”

Keruntuhan ini diselamatkan oleh konsep “Ideal” (Bilangan Ideal) yang diciptakan oleh matematikawan abad ke-19. Alih-alih melihat elemen itu sendiri, dengan mempertimbangkan “himpunan kelipatan (ideal)” yang dihasilkan oleh elemen tersebut, faktorisasi prima menjadi mungkin kembali.

Dalam cincin bilangan bulat dari medan aljabar $\mathcal{O}_K$ (cincin yang lebih sempurna yang mengandung $\mathbb{Z}[\alpha]$), bahkan jika elemen tidak dapat difaktorkan secara unik, terbukti bahwa “Ideal selalu dapat difaktorkan secara unik sebagai hasil kali ‘Ideal Prima’ ($\mathfrak{p}$)”.

Oleh karena itu, di GNFS, alih-alih memfaktorkan elemen $(a - b\alpha)$ itu sendiri, kita melakukan faktorisasi ideal prima pada ideal utama $\langle a - b\alpha \rangle$ yang dihasilkannya.

Tahap 3: Norma (Norm) dan Dua Saringan (Sieve)

Lalu, bagaimana kita tahu ke ideal prima mana ideal $\langle a - b\alpha \rangle$ terurai? Di sini kita menggunakan sebuah fungsi yang disebut “Norma” (Norm). Norma adalah fungsi yang mengubah elemen kompleks dari medan aljabar menjadi “bilangan bulat biasa $\mathbb{Z}$” di dunia nyata.

Norma dari elemen $(a - b\alpha)$ dihitung dengan polinomial sederhana $b^d f(a/b)$ (di mana $d$ adalah derajat $f(x)$).

Berdasarkan teorema aljabar, diketahui bahwa “jika norma suatu ideal dapat difaktorkan sepenuhnya oleh bilangan prima kecil (halus), maka ideal aslinya juga dapat difaktorkan sepenuhnya oleh ideal prima kecil”.

Oleh karena itu, GNFS secara bersamaan menghitung dua hal berikut untuk sejumlah besar pasangan bilangan bulat $(a, b)$, dan hanya mengumpulkan pasangan di mana keduanya adalah “bilangan halus”:

Saringan Rasional (Rational Sieve): $a - bm$ (nilai di dunia nyata)
Saringan Aljabar (Algebraic Sieve): $b^d f(a/b)$ (norma di dunia medan aljabar)

Kita mengumpulkan puluhan juta pasangan $(a, b)$ yang keduanya halus, memecahkan data faktorisasi prima ideal (berapa banyak ideal prima yang ada) sebagai matriks raksasa (aljabar linear atas GF(2)), dan menemukan himpunan $S$ dari pasangan sedemikian rupa sehingga “ketika dikalikan, pangkat semua ideal prima menjadi genap”.

Tahap 4: Dua “Rintangan” dan Grup Kelas Ideal

Melalui perhitungan matriks, kita menemukan bahwa mengalikan semua ideal $(a - b\alpha)$ dalam himpunan $S$ menghasilkan kuadrat dari suatu ideal $I$.

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

Namun, ini belum berakhir. Tembok matematika terdalam dan tersulit di GNFS ada di sini.

Apa yang pada akhirnya kita inginkan bukanlah “kuadrat dari ideal”, melainkan “kuadrat dari elemen” ($\gamma^2$) untuk disubstitusikan ke dalam pemetaan $\phi$. Hanya karena ideal dikuadratkan, tidak berarti elemen itu sendiri dikuadratkan. Ada dua rintangan matematika yang sangat kuat (Obstructions) di sini.

Rintangan 1: Tembok Grup Kelas Ideal (Ideal Class Group)

Ideal $I$ tidak selalu “ideal yang dihasilkan oleh satu elemen (ideal utama)”. Mustahil untuk mengekstrak elemen spesifik $\gamma$ dari ideal yang bukan merupakan ideal utama.

Di sinilah konsep “Grup Kelas Ideal (Class Group, $Cl_K$)” muncul. Grup Kelas Ideal adalah sebuah grup yang mengukur “berapa banyak ideal non-utama yang ada di dunia medan aljabar (seberapa banyak keunikan faktorisasi prima telah rusak)”. Bahkan jika $\prod \langle a - b\alpha \rangle$ menjadi $I^2$, jika $I$ bukan elemen identitas (ideal utama) dalam grup kelas ideal, kita tidak dapat menariknya kembali menjadi kuadrat elemen.

Rintangan 2: Tembok Grup Unit (Unit Group)

Misalkan kita beruntung dan $I$ adalah ideal utama $\langle \gamma \rangle$. Maka, $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Anda mungkin berpikir, “Bagus, elemennya juga kuadrat!”, tetapi Anda salah besar.

Fakta bahwa ideal (himpunan kelipatan) sama tidak berarti bahwa elemen-elemennya sepenuhnya sama. Akan selalu ada pergeseran berupa “Unit” (bilangan yang kebalikannya juga berupa bilangan bulat, seperti 1 atau -1). Dengan kata lain, persamaan elemen yang sebenarnya adalah sebagai berikut:

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

(di mana $u$ adalah elemen dari grup unit $U_K$)

Kecuali unit $u$ ini sendiri adalah kuadrat dari sesuatu (elemen kuadrat), sisi kiri tidak akan pernah bisa menjadi “kuadrat elemen yang sempurna”.

Tahap 5: Sihir Adleman “Karakter Kuadratik” (Quadratic Characters)

Rintangan grup kelas ideal dan rintangan grup unit. Bagaimana kita mengatasi keduanya? Di sinilah muncul metode jenius yang disebut “Karakter Kuadratik” (Quadratic Characters), yang diperkenalkan oleh kriptografer Leonard Adleman (huruf “A” di RSA) dan rekan-rekannya.

Untuk menentukan apakah “suatu elemen benar-benar kuadrat sempurna di medan aljabar”, kita menggunakan versi medan aljabar dari simbol Legendre (residu kuadrat). Pada matriks raksasa tadi (teka-teki untuk membuat jumlah ideal prima genap), kita secara diam-diam menambahkan beberapa lusin kondisi tambahan (kolom) yang menyatakan bahwa “karakter kuadratik untuk beberapa ideal prima khusus $\mathfrak{q}$ juga semuanya menjadi $1$ (genap)”.

Ketika kita menemukan himpunan $S$ yang memenuhi kondisi tambahan ini melalui perhitungan matriks, sebuah teorema mendalam dari teori bilangan aljabar menjamin bahwa “baik rintangan grup kelas ideal maupun rintangan grup unit secara alami akan hilang dengan probabilitas yang sangat tinggi”.

Dengan ini, kita akhirnya mendapatkan persamaan yang sebenarnya:

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

Tahap Akhir: Penyatuan Dunia dan Keruntuhan Kriptografi

Akhirnya, semua potongan teka-teki sudah lengkap.

[Elemen di Dunia Medan Aljabar (Dunia A)] $\gamma^2 = \prod (a - b\alpha)$ (Gunakan algoritma akar kuadrat untuk menemukan $\gamma$)

[Elemen di Dunia Nyata (Dunia Rasional)] $V^2 = \prod (a - bm)$ (Ini hanyalah perkalian bilangan bulat biasa, jadi akar kuadrat $V$ dapat ditemukan dengan mudah)

Sekarang, saatnya jembatan ajaib pertama yang kita buat, homomorfisme $\phi$, beraksi. Kita melompati elemen $\gamma$ dari Dunia A ke Dunia B (dunia sisa $N$) menggunakan $\phi$ (pemetaan yang menyubstitusikan $m$ ke dalam $\alpha$).

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

Di sisi lain, kita membawa $V$ yang dibuat di dunia nyata langsung ke dunia sisa dan menyebutnya $X$.

$$X = V \pmod N$$

Berkat sifat “mempertahankan struktur” dari homomorfisme, hubungan kuadrat yang berlaku di Dunia A dipertahankan dengan sempurna di Dunia B (dunia modulo $N$). Lebih jauh lagi, karena pasangan asli $(a, b)$ dibentuk dengan cara yang berkorespondensi sebagai $a - b\alpha$ dan $a - bm$, $X$ dan $Y$ ini saling bertabrakan di dunia modulo $N$ dan menghasilkan persamaan absolut berikut:

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

Sekarang, tinggal berdoa agar $X$ dan $Y$ bukan merupakan solusi trivial ($X \equiv \pm Y$), lalu kita hitung: $\gcd(X - Y, N)$

Jika itu adalah solusi non-trivial, algoritma Euclidean akan melesat dalam 0,001 detik, dan bilangan prima rahasia $p$ dan $q$, yang merupakan jantung kriptografi RSA, akan dicetak di layar keluaran.

Inilah bentuk utuh dari “General Number Field Sieve (GNFS)” yang mengumpulkan intisari matematika modern.

Apa Itu Matematika Terkuat Umat Manusia 'General Number Field Sieve (GNFS)' yang Membobol Kriptografi Internet?

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

Apa Itu Matematika Terkuat Umat Manusia “General Number Field Sieve (GNFS)” yang Membobol Kriptografi Internet?

Internet yang kita gunakan setiap hari. Semua komunikasi, seperti pesan LINE, YouTube, dan belanja di Amazon, dilindungi oleh “kriptografi”. Saat ini, kriptografi yang paling banyak digunakan di dunia adalah “Sandi RSA”.

Inti dari pertahanan Sandi RSA sangatlah sederhana. Ia memanfaatkan sifat matematika bahwa “faktorisasi prima dari angka yang sangat besar tidak dapat dipecahkan bahkan oleh komputer sekalipun” . Sebagai contoh, untuk “15”, kita langsung tahu bahwa itu adalah “3 × 5”, tetapi saat angkanya menjadi “270 digit”, menggabungkan seluruh superkomputer di dunia pun akan memakan waktu ratusan juta tahun untuk memecahkannya.

Namun, para matematikawan tidak tinggal diam. Untuk menembus pertahanan sandi yang tak tertembus ini, umat manusia telah menciptakan sebuah algoritma (prosedur perhitungan) ajaib yang disebut “General Number Field Sieve (GNFS)” .

Dalam artikel ini, tanpa menggunakan istilah teknis sama sekali, hanya dengan pengetahuan matematika sekolah menengah pertama (faktorisasi prima, aljabar, faktor persekutuan terbesar) , kami akan menjelaskan langkah demi langkah secara lengkap bagaimana “algoritma terkuat umat manusia” ini memecahkan sandi!

Bab 1: Tujuan Dekripsi adalah “Rumus Kelas 3 SMP”

Jurus andalan terbesar untuk menghadapi faktorisasi prima angka raksasa. Itu adalah rumus yang dipelajari di kelas 3 SMP ini.

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

Mungkin Anda berpikir, “Hah, rumus dasar seperti ini bisa memecahkan sandi?”. Namun, inilah kunci utama yang mengungkap segalanya.

Tujuan utama untuk memecahkan sandi adalah, terhadap angka raksasa $N$, menemukan “angka ($X$ dan $Y$) di mana sisa pembagian $X^2$ dan $Y^2$ oleh $N$ adalah sama” .

Mengapa “Sisa yang Sama” Dapat Memecahkan Sandi?

Misalkan dua angka, $X^2$ dan $Y^2$, memiliki “sisa yang sama jika dibagi dengan $N$”. Sisa yang sama berarti, hasil pengurangannya yaitu "$X^2 - Y^2$" pasti bisa dibagi habis oleh $N$ (merupakan kelipatan $N$) .

Di sini, mari asumsikan angka raksasa $N$ yang digunakan dalam sandi terbentuk dari perkalian dua bilangan prima rahasia ($p$ dan $q$) ($N = p \times q$).

Jika $X^2 - Y^2$ difaktorkan, hasilnya adalah $(X - Y)(X + Y)$ . Fakta bahwa ini adalah kelipatan $N$ berarti di suatu tempat dalam perkalian ini tersembunyi bilangan prima rahasia $p$ dan $q$.

Keajaiban terjadi di sini. Probabilitas secara matematis bahwa dua bilangan prima $p$ dan $q$ akan masuk ke ruangan yang berbeda, yaitu "$p$ ke ruangan $(X - Y)$" dan “$q$ ke ruangan $(X + Y)$” , adalah 50% (setengah) .

Dengan asumsi hanya bilangan prima $p$ yang masuk ke ruangan $(X - Y)$, mari kita hitung “faktor persekutuan terbesar (komponen terbesar yang sama)” dari $(X - Y)$ dan $N$.

Isi $(X - Y)$ = $p \times$ angka tertentu
Isi $N$ = $p \times q$ Satu-satunya komponen yang sama adalah "$p$" !

Artinya, saat kita menghitung faktor persekutuan terbesar, bilangan prima rahasia $p$ akan langsung terungkap, dan sandi akan berhasil dipecahkan sepenuhnya. (Faktor persekutuan terbesar bisa dihitung dalam sekejap bahkan menggunakan ponsel dengan “Algoritma Euclidean”)

[Kolom Singkat: Mengapa Pangkat Dua? Pangkat Tiga atau Dikali Dua Tidak Bisa?]

Jika “$2X - 2Y$”, hasilnya adalah $2(X - Y)$, sehingga hanya ada satu ruangan dan bilangan prima tidak dapat dipisahkan. Jika “$X^3 - Y^3$”, ukuran ruangan akan tidak seimbang, sehingga perhitungan menjadi sia-sia dan berat. Untuk memisahkan dua bilangan prima, membaginya dengan indah menjadi dua ruangan “pangkat dua” adalah yang paling efisien.

Bab 2: Bagaimana Mencari X dan Y? “Teka-teki Mengumpulkan Kartu Bilangan Prima”

Tujuannya sudah jelas. Namun, jika kita menebak-nebak mencari “$X^2$ dan $Y^2$ yang sisanya sama”, kita tidak akan menemukannya sampai alam semesta kiamat. Oleh karena itu, matematikawan memikirkan metode jenius yang disebut “Teka-teki Mengumpulkan Kartu Bilangan Prima” .

Langkah 1: Menyaring dan Mengumpulkan Hanya Serbuk Emas (Angka yang Halus)

Pertama, siapkan angka sembarang $Z$, kuadratkan, dan hitung sisa $W$ ketika dibagi $N$. (Dunia sisa dari $Z^2 = W$)

Faktorkan sisa $W$ yang muncul. Di sini, hanya jika muncul "$W$ yang hanya terdiri dari bilangan prima kecil seperti 2, 3, 5, 7" , kita simpan persamaan tersebut sebagai “kartu pemenang”, dan membuangnya jika ada bilangan prima besar yang tercampur. Ini seperti menyaring batu-batu besar di sungai dan hanya mengumpulkan serbuk emas.

Langkah 2: Teka-teki Membuat Semua Berjumlah “Genap”

Misalnya, terkumpul tiga kartu serbuk emas berikut.

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

Mari kita kalikan semuanya. Sisi kanan menjadi $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, jika disederhanakan menjadi "$2^4 \times 3^2 \times 5^2$" .

Luar biasa, jumlah bilangan prima menjadi “4, 2, 2”, semuanya berjumlah genap ! Jika semuanya genap, berarti kita bisa membagi dua jumlahnya untuk menjadikannya “pangkat dua dari sesuatu”. Artinya, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Karena sisi kiri adalah $(Z_1 \times Z_2 \times Z_3)^2$, akhirnya kita mendapatkan, $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$ Pasangan “$X^2 = Y^2$” yang ditunggu-tunggu pun selesai!

Bagi komputer, memecahkan teka-teki apakah jumlah bilangan prima “genap atau ganjil (0 atau 1)” adalah hal yang sangat mudah, jadi dengan metode ini $X$ dan $Y$ bisa ditemukan dengan sangat cepat.

Bab 3: Tembok Keputusasaan yang Menghadang

Dengan ini semua sandi bisa dipecahkan! …begitulah yang dipikirkan, hingga sebuah masalah besar muncul. Jika angka sandi $N$ berukuran hingga sekitar “100 digit”, metode ini (disebut Quadratic Sieve) bisa menyelesaikannya. Namun, jika $N$ menjadi “200 digit atau 300 digit”, nilai $W$ yang muncul di tengah perhitungan menjadi terlalu besar.

Jika angkanya terlalu besar, “angka yang hanya terdiri dari bilangan prima kecil (serbuk emas)” akan berhenti muncul. Ini menjadi lebih sulit daripada mencari lensa kontak di padang pasir, dan kita tidak bisa mengumpulkan kartu sama sekali untuk memecahkan teka-teki.

Di sinilah akhirnya senjata pamungkas umat manusia, “General Number Field Sieve (GNFS)” , muncul.

Bab 4: Ide Terkuat Umat Manusia Membuat “Dua Dunia”

Ide jenius GNFS adalah, “Karena kita hanya menghitung di dunia nyata, angkanya menjadi besar. Kalau begitu, mari buat ‘dunia di balik layar’ menggunakan polinomial (aljabar), dan bagi beban perhitungannya menjadi dua” .

Keajaiban Aljabar

GNFS mengubah angka raksasa $N$ menjadi bentuk aljabar menggunakan angka dasar $m$. Misalnya, jika $N=100$, dengan $m=4$, maka $100 = 4^3 + 2(4^2) + 4$. Menggunakan huruf $x$, ini diubah menjadi persamaan (dunia balik layar) $f(x) = x^3 + 2x^2 + x$ .

Hal yang menarik dari persamaan ini adalah sifatnya: “Jika huruf $x$ disubstitusi dengan $m$ (4 dalam contoh di atas), ia akan selalu melesat kembali ke angka dunia nyata $N$” .

Mencari Serbuk Emas di Dua Dunia Sekaligus

GNFS membuat banyak pasangan bilangan bulat sembarang $(a, b)$, dan melakukan dua perhitungan berikut secara bersamaan.

Dunia nyata: $a - b \times m$
Dunia aljabar: Nilai perhitungan $a - b \times x$ berdasarkan aturan aljabar

Dengan membagi masalah ke dalam dua dunia, ukuran angka yang ditangani berkurang (menjadi lebih ringan) secara drastis. Bayangkan memecah batu raksasa menjadi dua batu kecil yang mudah dikelola.

Kemudian, dengan menggunakan saringan, kumpulkan HANYA pasangan $(a, b)$ ajaib di mana “Baik di dunia nyata maupun di dunia aljabar, keduanya ‘hanya terdiri dari bilangan prima kecil (serbuk emas)’” . Inilah asal mula nama “Number Field Sieve”.

Saat Sandi Akhirnya Dipecahkan

Ketika puluhan juta “kartu serbuk emas” dari kedua dunia terkumpul, gunakan kalkulasi matriks raksasa dari superkomputer untuk menemukan “kombinasi di mana semua jumlah bilangan prima genap”, persis seperti di Bab 2.

Setelah kombinasi ditemukan,

Jadikan angka pangkat dua yang terbentuk di dunia nyata sebagai $X^2$
Jadikan rumus pangkat dua yang terbentuk di dunia aljabar sebagai $Y(x)^2$

Terakhir, substitusikan $x$ dalam $Y(x)$ dari dunia aljabar dengan $m$, memindahkan dan menggabungkannya ke dunia nyata. Lalu, seperti keajaiban matematika, kondisi “sisa pembagian $X^2$ dan $Y^2$ sama” akan terbentuk dengan sempurna!

Setelah itu, seperti di Bab 1, dengan menghitung faktor persekutuan terbesar dari $X - Y$ dan $N$, sandi RSA yang tak tertembus akan hancur lebur, dan bilangan prima rahasia akan terungkap.

Penutup: Matematika Tidak Berakhir

Anda mungkin berpikir, “Bagus, dengan GNFS sandi apapun bisa dipecahkan!”. Namun, sandi RSA tidak menyerah begitu saja. Sandi yang digunakan di internet saat ini adalah angka raksasa mengerikan yang disebut “RSA-2048 (sekitar 617 digit)”.

Meskipun GNFS adalah algoritma terkuat umat manusia, bahkan untuk memecahkan 270 digit (RSA-270) sekalipun, dikatakan akan memakan waktu ribuan hingga puluhan ribu tahun meskipun seluruh komputer di dunia digabungkan. Untuk saat ini, data LINE dan bank kita aman.

Namun, apa yang akan terjadi jika muncul “keajaiban yang bisa menemukan $X$ dan $Y$ dalam sekejap untuk angka sebesar apa pun” ? Sebenarnya, entitas terdekat dengan hal tersebut saat ini sedang dalam pengembangan, yaitu “Komputer Kuantum (Algoritma Shor)” . Telah dibuktikan secara matematis bahwa dengan menggunakan sifat gelombang mekanika kuantum, teka-teki pengumpulan kartu yang merepotkan dapat dilewati untuk menarik jawaban sekaligus.

Persaingan kecerdasan yang tiada akhir antara pembuat sandi (pertahanan) dan pembuat algoritma pemecah sandi (serangan). Mengetahui bahwa “faktorisasi prima” dan “aljabar” yang dipelajari di SMP sebenarnya adalah senjata yang saling bertabrakan di garis depan keamanan dunia, bukankah kelas matematika sekarang terlihat sedikit lebih menarik?

Orang yang menemukan algoritma terkuat di masa depan, mungkin saja adalah Anda yang sedang membaca artikel ini!

(※Artikel ini mengonsepkan daya tarik matematis dari pemecahan sandi untuk pelajar SMP. GNFS yang sebenarnya dihitung secara ketat menggunakan matematika universitas tingkat lanjut seperti grup kelas ideal dari medan aljabar dan homomorfisme)

Penjelasan Sederhana tentang Dugaan Kepler

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

Penjelasan Sederhana tentang Dugaan Kepler! 〜Cara Menyusun Semangka Serapat Mungkin〜

Halo, ini kenji!

Hari ini saya ingin mencoba menjelaskan masalah matematika yang namanya terdengar agak sulit, yaitu “Dugaan Kepler”, dengan cara yang sesederhana mungkin.

Sekilas, ini mungkin terdengar seperti topik yang sangat spesifik, tetapi sebenarnya ini adalah masalah yang cukup dekat dengan kehidupan sehari-hari, seperti “bagaimana cara memasukkan semangka ke dalam kotak sepadat mungkin?”. Ini juga berhubungan dengan kulkas di minimarket dan cara menumpuk barang bawaan.

Dan di dunia matematika, ini adalah cerita yang sangat romantis tentang masalah yang tidak bisa dibuktikan selama lebih dari 400 tahun .

Mari kita mulai!

Siapa itu Kepler?

Pertama-tama, siapa “Kepler” dalam “Dugaan Kepler”?

Ini adalah nama seorang astronom dan matematikawan Jerman, Johannes Kepler .

Orang ini sangat luar biasa. Misalnya, dialah yang menemukan bahwa orbit planet berbentuk elips. Ini adalah pengetahuan yang umum saat ini, tetapi pada masa itu (sekitar tahun 1600) bahkan teori heliosentris belum sepenuhnya dipercaya.

Galileo = Jenius observasi
Kepler = Jenius yang menjelaskan alam semesta dengan rumus
Newton = Super jenius yang merangkum teori-teori tersebut menjadi hukum fisika

Dengan posisi seperti itu, Kepler adalah pionir dalam “menjelaskan alam semesta dengan persamaan matematika”.

Dan kemudian suatu hari dia mengatakan ini.

Apa itu Dugaan Kepler?

Secara sederhana, “Dugaan Kepler” adalah masalah ini.

Saat memasukkan bola dengan ukuran yang sama (seperti semangka atau jeruk) ke dalam kotak, susunan mana yang paling padat?

Masalah seperti ini.

Lalu apa yang Kepler duga pada tahun 1600-an adalah

Bukankah menumpuknya seperti bentuk segitiga, seperti menata jeruk di pasar sayur, adalah yang paling efisien?

Dalam bahasa matematika, ini disebut “Masalah Pengepakan Bola” (Sphere Packing Problem) , yaitu masalah mencari cara menyusun bola serapat mungkin dalam suatu ruang.

Kepler menduga bahwa susunan “Face-Centered Cubic (FCC)” (mirip dengan menumpuk semangka dalam bentuk segitiga) adalah yang paling efisien.

Dan orang-orang berpikir, “Itu memang masuk akal,” tapi terbukti sangat sulit untuk membuktikan secara matematis bahwa “ini jelas yang terbaik!”.

400 Tahun untuk Membuktikan!?!

Lalu, kapan sebenarnya itu terbukti?

Mengejutkannya, sekitar tahun 1998 - 2005 . Artinya, hampir 400 tahun tidak ada yang bisa membuktikannya . Luar biasa.

Selain itu, orang yang membuktikannya adalah matematikawan Amerika, Thomas Hales .

Orang ini menyadari bahwa tidak mungkin melakukannya dengan perhitungan manual, jadi dia menggunakan komputer untuk membuktikannya . Namun, buktinya terlalu rumit sehingga manusia tidak bisa memeriksanya dengan benar! Masalah pun muncul.

Oleh karena itu, terjadi perdebatan besar di dunia matematika, “Apakah kita benar-benar bisa mempercayai bukti komputer?”.

Akhirnya, “bukti formal” yang dikonfirmasi secara ketat, termasuk dengan komputer, diselesaikan pada tahun 2014 .

Dengan kata lain, butuh lebih dari 400 tahun hingga intuisi Kepler terbukti benar. Betapa romantisnya.

Ini Sangat Sering Digunakan di Kehidupan Nyata

Anda mungkin berpikir bahwa “bagaimana cara menumpuk bola” hanya dibicarakan oleh para kutu buku matematika, tetapi sebenarnya ini sangat praktis.

Mengemas minuman secara efisien di kulkas minimarket
Menumpuk kaleng di palet transportasi
Juga diterapkan dalam telekomunikasi (seperti kompresi sinyal digital)
Digunakan dalam desain printer 3D dan struktur kristal

Dan masih banyak lagi. Faktanya, ini adalah teori yang banyak digunakan di balik kehidupan kita.

Kesimpulan: Intuisi Manusia Itu Luar Biasa

Jadi, mari kita rangkum.

Dugaan Kepler = Masalah bagaimana cara mengemas bola serapat mungkin
Pak Kepler = Matematikawan/astronom yang menemukan orbit planet
Diduga pada tahun 1600-an! Tetapi dibuktikan pada tahun 2000-an!
Sangat diaplikasikan dalam kehidupan nyata!

Dan hal yang paling menarik adalah “cara pedagang sayur menumpuk buah berdasarkan insting ternyata yang terbaik secara matematis” .

Dengan kata lain, intuisi manusia itu luar biasa . Dan fakta bahwa butuh waktu 400 tahun untuk membuktikannya membuat cerita ini sangat romantis.

Jika Anda tertarik, silakan cari “Thomas Hales”, “Formal Proof”, atau “Sphere Packing”. Jika digali lebih dalam, ini akan sangat menarik.

Sampai jumpa!

[PR]

今すぐ購入

Konjektur Collatz

Tue, 15 Jul 2025 18:03:03 +0900

“Benarkah semua angka akhirnya akan menjadi 1?” ── Bermain dengan Konjektur Collatz

Halo! Saya Kenji.

Tiba-tiba saja, ketika Anda mendengar “aturan yang membuat angka apa pun pada akhirnya akan menjadi 1”, bukankah itu terasa sedikit aneh?

Misalnya, 19, atau 87, atau bahkan 1000000. Jika Anda mengikuti aturan tertentu dan memanipulasi angka, entah mengapa itu selalu berakhir di “1”.

Kisah seperti mimpi ini adalah Konjektur Collatz (Collatz Conjecture).

Pertama-tama, apa itu Konjektur Collatz?

Mari saya perkenalkan aturannya terlebih dahulu.

Mulai: Pilih bilangan bulat positif apa pun
Operasi:
- Jika genap → bagi dua (n → n / 2)
- Jika ganjil → kalikan dengan 3 lalu tambah 1 (n → 3n + 1)

Jika Anda mengulangi ini terus-menerus, tebakannya adalah angka apa pun pada akhirnya akan mencapai 1.

Misalnya, jika kita mulai dengan 6:

1

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

Itu benar-benar menjadi “1”. Selamat datang kembali!

Mari kita coba dengan kode: Collatz dengan Python

Nah, dalam kasus seperti ini, lebih cepat untuk mencoba membuat kodenya! Mari kita cetak “Barisan Collatz” menggunakan Python.

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


def collatz(n):
 steps = [n]
 while n != 1:
 if n % 2 == 0:
 n = n // 2
 else:
 n = 3 * n + 1
 steps.append(n)
 return steps

# Contoh: mari kita mulai dari 19
print(collatz(19))

Saat dijalankan:

1

[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Ini berhasil mencapai 1. Mengambil jalan memutar yang cukup panjang, tetapi pada akhirnya tiba di garis finis!

Omong-omong, meskipun kita mulai dari 29, itu akan mencapai 1 dengan cara yang sama.

1

pythonprint(collatz(29))

Saat dijalankan:

1
2
3
4
5
6
7
8


[27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242,
121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350,
175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167,
502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479,
1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911,
2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35,
106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Itu memakan waktu hingga 111 langkah!

Terlebih lagi, dalam perjalanannya terkadang membengkak hingga lebih dari 9000. Ini adalah pola di mana ia mengambil jalan memutar yang sangat jauh sebelum mencapai finis.

Jadi, apa yang membuatnya begitu menakjubkan?

Yang menakjubkan dari konjektur ini adalah,

Meskipun belum terbukti, tampaknya selalu berakhir pada 1 tidak peduli angka apa yang Anda gunakan

Di situlah letak kehebatannya.

Hah? Lalu bagaimana dengan satu triliun, atau satu kuadriliun…?

Bagi Anda yang memikirkan hal itu, Anda sangat tajam. Faktanya, menggunakan komputer, ini telah diverifikasi hingga sekitar “2 pangkat 68”, dan semuanya mencapai 1. Luar biasa…

Tapi, belum terbukti secara teoritis bahwa “semuanya akan seperti itu”. Inilah yang disebut “masalah yang belum terpecahkan” di dunia matematika.

Siapa Bapak Collatz?

Nah, setelah membaca sejauh ini, Anda mungkin bertanya-tanya, “Siapa itu Collatz?” Saya akan memperkenalkannya dengan benar!

Nama: Lothar Collatz (Lothar Collatz)
Kebangsaan: Jerman
Tahun lahir: 1910 - 1990
Profesi: Matematikawan (aktif di bidang analisis fungsional dan teori bilangan)

Dia mengusulkan konjektur ini pada tahun 1937, dan sejak saat itu, selama lebih dari 80 tahun, belum ada yang bisa membuktikan atau menyangkalnya.

Omong-omong, masalah ini sangat sederhana tetapi sangat dalam, sehingga bahkan Paul Erdős (matematikawan super terkenal) mengatakan sesuatu seperti ini.

“Matematika belum cukup matang untuk menangani Collatz.”

Dengan kata lain, ada teori bahwa matematika umat manusia belum mengejar misteri ini…

“Rumus matematika yang rumit” tidak diperlukan

Hal yang baik tentang Konjektur Collatz adalah siapa pun bisa memainkannya.

Anda hanya butuh kertas dan pulpen. Jika Anda menulis kode dengan Python, Anda dapat mengujinya secara otomatis. Namun demikian, matematikawan mutakhir dengan serius menantangnya.

Tidakkah itu terasa mengasyikkan?

Bonus: Kode untuk menguji sekaligus

Saya juga akan menyertakan kode untuk menguji banyak angka sekaligus.

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps} (jumlah langkah: {len(steps)-1})")

Ini akan mencetak barisan Collatz untuk “1 hingga 20” sekaligus.

Kesimpulan: Dunia ini memang aneh

Jadi begitulah, Konjektur Collatz.

Meskipun sangat sederhana
Tidak ada yang bisa membuktikannya
Ini adalah masalah besar di dunia matematika

Itu menjadi sesuatu yang terasa seperti kumpulan misteri.

Bahkan pemula dalam pemrograman bisa mencobanya, jadi silakan memainkannya!

Tautan yang disarankan (bagi yang tertarik)

Wikipedia: Konjektur Collatz
Makalah Terence Tao (Bahasa Inggris)
Mungkin juga menyenangkan untuk membuat versi visualisasi menggunakan Python! (Jika ada permintaan, saya akan membuatnya)

Jika Anda ingin mengetahui lebih banyak cerita tentang “matematika misterius × pemrograman”, jangan ragu untuk meminta “ceritakan lebih banyak”. Suatu hari nanti, saya akan memperkenalkan Hipotesis Riemann, bilangan prima, dan banyak lagi!

📮 Selesai!

Dugaan P≠NP

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

Ringkasan

1

Kelas P adalah kelas masalah yang dapat diputuskan dalam waktu polinomial pada mesin Turing deterministik, dan kelas NP adalah kelas masalah di mana, ketika diberikan bukti bahwa jawabannya adalah Ya (disebut Saksi), kebenaran Saksi tersebut dapat diverifikasi dalam waktu polinomial (ini disebut verifikasi). Karena masalah yang dapat diputuskan dalam waktu polinomial dapat diverifikasi dalam waktu polinomial, jelas bahwa P⊆NP, namun belum jelas apakah P merupakan himpunan bagian sejati dari NP. Walaupun belum ada buktinya, banyak peneliti percaya bahwa P≠NP. Dugaan bahwa kelas P dan kelas NP tidak sama disebut "Dugaan P≠NP".

Situs referensi : https://daigakudenki.com/np-hard/

Kode Bahasa C untuk Menghasilkan Bilangan Prima

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

Berikut ini adalah kode sederhana dalam bahasa C untuk menghasilkan bilangan prima dalam rentang yang ditentukan. Dalam contoh ini, kita mencantumkan bilangan prima dari 1 hingga n.

 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("Masukkan nilai maksimum rentang untuk menghasilkan bilangan prima: ");
 scanf("%d", &n);
 printf("Bilangan prima dari 1 hingga %d adalah sebagai berikut:\n", n);
 printPrimes(n);
 return 0;
}

Kode ini bekerja sebagai berikut:

Fungsi isPrime: Menentukan apakah angka yang diberikan adalah bilangan prima. Demi efisiensi, pertama-tama diperiksa apakah habis dibagi 2 dan 3, dan kemudian dilanjutkan dengan memeriksa kelipatan 6.
Fungsi printPrimes: Mencetak bilangan prima dalam rentang yang ditentukan. Angka 2 dicetak terlebih dahulu, dan kemudian hanya bilangan ganjil yang diperiksa.
Fungsi main: Meminta pengguna untuk memasukkan nilai maksimum rentang, dan mencetak bilangan prima dalam rentang tersebut.

Saat kode ini dikompilasi dan dijalankan, bilangan prima dalam rentang yang ditentukan akan ditampilkan.

Pengantar Mathematica

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

Pengantar Mathematica

Menyelesaikan persamaan

1

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

Output

1

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

Mencari solusi persamaan dalam rentang bilangan bulat

1

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

Output

1

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

Menyelesaikan sistem persamaan

1

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

Output

1

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

Menyelesaikan pertidaksamaan

1

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

Output

1

x < 1 || x > 2

Diferensiasi

1

D[x^2, x]

Output

1

2 x

Integrasi

1

Integrate[x^2, x]

Output

1

x^3/3

Mencari limit

1

Limit[1/x, x -> 0]

Output

1

Infinity

Mencari deret

1

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

Output

1

π^2/6

Membuat matriks

1

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

Mencari perkalian matriks

1

m . m

Output

1

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

Mencari matriks invers

1

Inverse[m]

Output

1

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

Mencari nilai eigen dan vektor eigen

1

Eigensystem[m]

Output

1

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

Mencari perkalian titik vektor

1

{1, 2} . {3, 4}

Output

1

11

Mencari perkalian silang vektor

1

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

Output

1

{-3, 6, -3}

Mencari besar vektor

1

Norm[{1, 2, 3}]

Output

1

√14

Mencari sudut vektor

1

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

Output

1

ArcCos[11/(√5 √25)]

Mencari proyeksi vektor

1

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

Output

1

{11/5, 22/5}

Mencari rotasi vektor

1

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

Output

1

{0, 1}

Mencari translasi vektor

1

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

Output

1

{4, 6}

Mencari penskalaan vektor

1

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

Output

1

{2, 3}

Mencari refleksi vektor

1

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

Output

1

{0, 0}

Menghasilkan bilangan acak

1

RandomReal[]

Output

1

0.123456

Menghasilkan bilangan acak (bilangan bulat)

1

RandomInteger[]

Output

1

123456

Menghasilkan bilangan acak (dengan rentang)

1

RandomReal[{1, 10}]

Output

1

5.6789

Menghasilkan bilangan acak (bilangan bulat, dengan rentang)

1

RandomInteger[{1, 10}]

Output

1

5

Menghasilkan bilangan acak (dengan distribusi)

1

RandomVariate[NormalDistribution[0, 1]]

Output

1

0.123456

Menghasilkan bilangan acak (distribusi, jumlah)

1

RandomVariate[NormalDistribution[0, 1], 10]

Output

1

{0.123456, 0.234567, ..., 0.987654}

Menghasilkan bilangan acak (distribusi, jumlah, seed)

1
2


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

Output

1

{0.123456, 0.234567, ..., 0.987654}

Menerapkan fungsi pada elemen array

1
2
3


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

Output

1

{1, 2, 3}

Mendefinisikan fungsi menggunakan ekspresi lambda

1
2


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

Output

1

9

Komposisi fungsi

1
2
3
4


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

Output

1

16

Merujuk pada hasil perhitungan sebelumnya

1

% + 1

Output

1

17

Fungsi murni

1

(#+3)&[5]

Output

1

8

Ekstraksi array

1
2


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

Output

1

{2, 4}

Apa itu Paradoks Ulang Tahun?

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

Tahukah Anda tentang paradoks ulang tahun?

Saya akan menceritakan kisah yang sedikit aneh. Menurut Anda, berapa banyak orang yang harus berkumpul agar “probabilitas ada orang yang memiliki hari ulang tahun yang sama” menjadi tinggi?

Misalnya, satu tahun memiliki 365 hari, jadi ketika dikatakan “jika 23 orang berkumpul, probabilitas ada orang yang berulang tahun sama adalah 50% atau lebih”… rasanya sedikit bertentangan dengan intuisi, bukan?

Namun ini benar-benar 50% atau lebih.

Mengapa hal seperti itu bisa terjadi?

Fenomena ini disebut “paradoks ulang tahun”. Namanya memang “paradoks”, tetapi ada alasan matematis yang masuk akal.

Jika jumlah orang adalah “n”, maka probabilitas tidak ada orang yang ulang tahunnya sama dapat dihitung dengan rumus berikut:

1

P(tidak ada yang sama) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

Dengan menguranginya dari 1, kita akan mendapatkan “probabilitas ulang tahun sama dengan seseorang”.

Melihat hasilnya…

Jumlah Orang	Probabilitas orang dengan ulang tahun sama
10 orang	Sekitar 11.7%
20 orang	Sekitar 41.1%
23 orang	Sekitar 50.7% (Perhatikan di sini!)
30 orang	Sekitar 70.6%
70 orang	Luar biasa sekitar 99.9%!

Dengan kata lain, dengan hanya 23 orang, ada kemungkinan lebih dari setengah bahwa ada orang yang berulang tahun pada hari yang sama. Sepertinya ini juga sangat berlaku di kelas sekolah atau rapat di tempat kerja.

Kesimpulan: Perbedaan antara intuisi dan matematika itu menarik

“Paradoks ulang tahun” adalah contoh menarik di mana intuisi kita berbeda dengan probabilitas matematika yang sebenarnya. Jika Anda mengetahui hal-hal seperti ini, Anda mungkin bisa memeriahkan obrolan ringan atau kuis!

Tautan Referensi

Paradoks Ulang Tahun (Wikipedia)

Masalah Monty Hall

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

Apa itu Masalah Monty Hall

Masalah Monty Hall adalah sebuah masalah yang berasal dari permainan di acara televisi Amerika Serikat “Let’s Make a Deal”, dengan penjelasan sebagai berikut.

Kondisi awal: Dari tiga pintu, satu di antaranya berisi hadiah, dan dua sisanya kosong.

Peserta memilih satu dari tiga pintu.
Pembawa acara membuka satu pintu yang kosong dari dua pintu yang tidak dipilih oleh peserta.
Peserta ditanya apakah ia ingin mengubah pilihan pintunya.

Pada titik ini, masalahnya adalah mempertimbangkan apakah lebih baik bagi peserta untuk mengubah pilihannya atau tidak.

Solusi

Solusi dari masalah Monty Hall adalah sebagai berikut.

Jika peserta tidak mengubah pintu yang dipilih pertama kali
- Peluang menang: 1/3
- Peluang kalah: 2/3
Setelah pembawa acara membuka pintu yang kosong
- Jika tidak mengubah pilihan, peluang menang: 1/3 (tidak berubah dari peluang menang di nomor 1)
- Jika mengubah pilihan, peluang menang: 2/3 (peluang selain menang di nomor 1)

Oleh karena itu, peluang peserta untuk menang lebih tinggi jika ia mengubah pilihannya.

Referensi

Wikipedia Monty Hall problem

Masalah Matematika yang Belum Terpecahkan

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

Masalah Matematika yang Belum Terpecahkan

Saya akan menjelaskan tentang beberapa masalah matematika yang belum terpecahkan. Meskipun masalahnya sendiri sederhana, masih banyak masalah yang belum terbukti.

Apakah ada bilangan sempurna yang tak terhingga jumlahnya?

Bilangan sempurna adalah bilangan asli yang jumlah pembagi positifnya, selain dirinya sendiri, sama dengan bilangan itu sendiri. Sebagai contoh,

6 memiliki pembagi 1, 2, 3, dan 1+2+3=6, jadi ini adalah bilangan sempurna.
28 memiliki pembagi 1, 2, 4, 7, 14, dan 1+2+4+7+14=28, jadi ini adalah bilangan sempurna.

Saat ini hanya 51 yang telah ditemukan, dan meskipun diperkirakan jumlahnya tidak terbatas, hal itu belum terbukti.

Konjektur Goldbach

Konjektur Goldbach adalah konjektur yang menyatakan bahwa setiap bilangan genap yang lebih besar dari 2 dapat dinyatakan sebagai jumlah dari dua bilangan prima. (Di sini, bilangan prima adalah bilangan asli yang tidak memiliki pembagi selain 1 dan dirinya sendiri).

Sebagai contoh,

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

Masalahnya sendiri sangat sederhana, tetapi masih belum terbukti hingga saat ini.

Hipotesis Riemann

Ini adalah konjektur yang menyatakan bahwa nol dari fungsi zeta Riemann terbatas pada bilangan genap negatif dan bilangan kompleks yang bagian realnya adalah 1 / 2.

Fungsi zeta Riemann didefinisikan sebagai berikut, di mana $s$ adalah bilangan kompleks dan $n$ adalah bilangan asli:

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

Sejarah Matematika

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

Tiga masalah konstruksi Yunani Kuno

Diberikan sebuah lingkaran, buatlah persegi dengan luas yang sama dengan lingkaran tersebut (Menguadratkan lingkaran)
Diberikan sudut sembarang, bagilah menjadi tiga bagian yang sama besar (Triseksi sudut)
Diberikan sebuah kubus, buatlah kubus dengan volume dua kali lipat dari kubus tersebut (Menggandakan kubus)

Spiral Archimedes

Pada sebuah bidang, putar sinar OB di sekitar titik tetap O dengan kecepatan seragam. Jika posisi awal adalah OA, dan titik P mulai bergerak dari O di sepanjang OB dengan kecepatan konstan pada saat yang sama ketika sinar mulai bergerak dari OA, maka garis yang digambar oleh titik P adalah spiral Archimedes.

Teorema Pappus

Sikloid
Konkoid Nicomedes
Sisoid Diocles
Metode garis singgung Fermat
Metode garis normal Descartes

Kronologi

Tahun	Peristiwa
Sekitar 3400 SM	Bangsa Sumeria menggunakan koin tanah liat sebagai alat hitung
Sekitar 3000 SM	Matematika hieroglif muncul di Mesir
Sekitar 2800 SM	Peradaban Lembah Indus menggunakan sistem ukuran dan berat desimal
Sekitar 2700 SM	Bangsa Mesir menggunakan tali dan triple Pythagoras untuk memeriksa sudut
Sekitar 2500 SM	Sempoa (abacus), alat yang digunakan untuk menghitung, ditemukan
Sekitar 2500 SM

Referensi

Sejarah matematika

Cara Menemukan Bilangan Prima Hingga 1000 Menggunakan Saringan Eratosthenes

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

Apa itu Saringan Eratosthenes

Saringan Eratosthenes adalah algoritma untuk menemukan semua bilangan prima hingga batas tertentu. Algoritmanya sederhana dan dapat diimplementasikan dengan langkah-langkah berikut:

Buat array boolean dengan N elemen dan inisialisasi semua elemen menjadi true.
Atur elemen ke-0 dan ke-1 dari array menjadi false (karena 0 dan 1 bukan bilangan prima).
Jika elemen ke-2 dari array adalah true, maka cetak 2 sebagai bilangan prima.
Atur semua elemen kelipatan 2 mulai dari $2^2$ menjadi false ※
Jika elemen ke-3 dari array adalah true, maka cetak 3 sebagai bilangan prima.
Atur semua elemen kelipatan 3 mulai dari $3^2$ menjadi false.
Ulangi proses yang sama untuk elemen ke-4, ke-5, …, ke-N.

※ Alasan kami menargetkan elemen dari kuadrat ke atas untuk diatur menjadi false adalah karena elemen yang lebih kecil dari kuadrat tersebut sudah diproses (pencacahan telah selesai).

Implementasi dalam 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;
 }
 }
 }
}

Versi yang Sedikit Lebih Cepat

Kami akan menerapkan versi yang sedikit lebih cepat dengan mempertimbangkan hal-hal berikut:

Alih-alih menginisialisasi array dengan true, inisialisasi dengan false (ini lebih cepat).
Karena kelipatan 2 bukan bilangan prima, kami mengabaikan proses mengubah kelipatan 2 menjadi false.
Tidak perlu melakukan perulangan hingga n; jika Anda menemukan bilangan prima hingga akar kuadrat dari n, Anda dapat menemukan bilangan prima hingga n.

 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);
 }
}

Referensi

Saringan Eratosthenes

Cara Menggambar Grafik Menggunakan Python (matplotlib.pyplot)

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

Prasyarat

Akun Google

Langkah-langkah

Akses https://colab.research.google.com/
Pilih “File” -> “Notebook baru”
Tempel dan jalankan kode berikut

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() # tampilkan legenda
plt.show()

Hasil

Referensi

matplotlib.pyplot — Matplotlib 3.5.3 documentation

Cara Mengaktifkan KaTeX (Tampilan Rumus Gaya LaTeX) di hugo

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

Apa itu KaTeX?

KaTeX adalah pustaka javascript untuk menampilkan rumus matematika bergaya LaTeX dalam HTML.

Secara khusus, Anda dapat menampilkan rumus seperti berikut ini:

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

Tampaknya ada pustaka tampilan rumus bergaya LaTeX lainnya, tetapi KaTeX dikenal karena sederhana dan cepat.

Cara menambahkan ke hugo

Buat file baru layouts/partials/math.html dalam hierarki folder hugo.

Isinya harus sebagai berikut:

 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>

Selanjutnya, tambahkan kode berikut ke file yang sudah ada layouts/partials/extend_head.html.

1
2
3


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

Sekarang Anda siap menggunakan KaTeX.

Dengan menambahkan math: true ke front matter halaman, Anda dapat mengaktifkan KaTeX.

Yang harus Anda lakukan adalah menulis rumus gaya LaTeX di badan artikel.

1

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

Saat ditulis seperti di atas, ini akan ditampilkan sebagai berikut:

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

Referensi

Menyelesaikan Masalah Pedagang Keliling dengan Mathematica

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

Menyelesaikan Masalah Pedagang Keliling dengan Mathematica

Masalah

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

Solusi

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];

Buat matriks menggunakan fungsi SparseArray. Setiap elemen mewakili jarak antara kota-kota di baris dan kolom elemen tersebut. Misalnya, elemen pertama {1,2}->10 berarti jarak antara 1 dan 2 adalah 10. Elemen kedua dari belakang {9,9} menunjukkan ukuran matriks, dan elemen terakhir Infinity berarti panjang jalur antar kota yang tidak ditentukan adalah tak terhingga. Dengan kata lain, itu berarti tidak ada jalan.

1

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

Anda dapat dengan mudah menyelesaikan masalah pedagang keliling dengan fungsi FindShortestTour. {1,2,3,4,5,6,7,8,9} mewakili nomor kota. DistanceFunction->(d[[#1,#2]]&) meneruskan matriks d yang mewakili jarak antar kota.

Keluaran

1

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

Keluarannya adalah jarak terpendek dan rute pada saat itu. Jarak terpendek adalah 137, dan rutenya adalah 1→2→5→9→8→7→6→3→4→1. Jika urutannya diubah menjadi ABC, maka akan menjadi A, B, E, I, H, G, F, C, D.

Rumus Matematika Favorit Saya

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

Teorema Wilson

Jika $p$ adalah bilangan prima, maka berlaku $(p−1)!≡−1 \pmod p$

Rumus Euler

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

Teorema Terakhir Fermat

Untuk bilangan bulat $n≥3$, tidak ada bilangan bulat positif $x,y,z$ yang memenuhi $x^n+y^n=z^n$

Masalah Basel

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

Polinomial penghasil bilangan prima Euler

$n^2+n+41$ menghasilkan bilangan prima untuk semua bilangan bulat $n$ dari $0$ hingga $39$