Math on kenji.blog

[Untuk Pemula] Menguraikan Struktur Matematis Model Transformer

Fri, 11 Sep 2026 22:00:00 +0900

Pendahuluan: Mengapa Belajar Matematika Transformer?

Arsitektur yang dapat dikatakan telah menulis ulang sejarah Pemrosesan Bahasa Alami (NLP) modern, dan bahkan seluruh AI, adalah “Transformer”. Diusulkan pertama kali dalam makalah “Attention Is All You Need” yang diterbitkan oleh para peneliti Google pada tahun 2017, model ini sekarang berfungsi sebagai jantung dari Model Bahasa Besar (LLM) yang menyapu dunia, seperti seri GPT OpenAI (teknologi dasar ChatGPT), BERT dari Google, dan Claude dari Anthropic.

Namun, meskipun penjelasan kualitatif seperti “memahami konteks menggunakan Attention (mekanisme perhatian)” untuk cara kerja Transformer sering ditemukan, saat ini ternyata masih sedikit penjelasan mendalam tentang struktur matematis di baliknya yang ditujukan untuk pemula. Untuk benar-benar memahami bagaimana AI memproses “kata-kata” sebagai “rumus matematika” dan menghasilkan teks yang sangat alami, sangat penting untuk menguraikan mekanisme matematisnya.

Dalam artikel ini, bagi mereka yang memiliki pengetahuan dasar matematika dan pemrograman (mereka yang memahami konsep matriks dan turunan tingkat sekolah menengah), kami akan menguraikan secara menyeluruh dan dengan cara yang mudah dipahami tentang struktur matematis seperti “Mekanisme Self-Attention”, “Model Query, Key, Value (Q/K/V)”, “Normalisasi dengan Fungsi Softmax”, dan “Positional Encoding” yang merupakan inti dari Transformer.

Anda mungkin akan kewalahan oleh deretan rumus matematika, tetapi setiap perhitungan memiliki “makna” yang jelas. Pada saat Anda selesai membaca artikel ini, Anda seharusnya dapat memahami bahwa Transformer bukanlah sekadar kotak hitam ajaib, melainkan kristalisasi dari matematika dan statistik yang dirancang secara presisi.

1. Keterbatasan Metode Konvensional dan Inovasi Transformer

Sebelum munculnya Transformer, arus utama pemrosesan bahasa alami adalah Recurrent Neural Network (RNN) dan turunannya, LSTM (Long Short-Term Memory). RNN dirancang untuk memproses data deret waktu, dan membaca kalimat kata demi kata dari awal secara berurutan.

Namun, RNN memiliki dua kelemahan fatal.

Kesulitan dalam mempelajari ketergantungan jangka panjang (Long-term dependencies): Seiring bertambahnya panjang kalimat, informasi dari kata-kata yang dimasukkan di awal akan memudar pada saat mencapai akhir (masalah gradien menghilang atau vanishing gradient problem).
Komputasi paralel tidak mungkin dilakukan: Karena kata-kata harus diproses secara berurutan, komputasi paralel skala besar menggunakan GPU menjadi sulit, dan pelatihan memakan waktu yang sangat lama.

Transformer sepenuhnya membuang struktur RNN dan menyebabkan pergeseran paradigma dengan menangkap konteks menggunakan “Attention” saja. Hal ini memungkinkan tidak adanya kehilangan informasi terlepas dari seberapa panjang deretannya, sekaligus menyejajarkan (paralel) perhitungan untuk memaksimalkan kinerja GPU.

2. Arsitektur Keseluruhan Transformer

Pertama-tama, mari kita lihat arsitektur Transformer secara keseluruhan. Transformer secara garis besar terdiri dari dua blok: “Encoder” dan “Decoder”. Mengambil tugas terjemahan sebagai contoh, Encoder mengubah bahasa input (misalnya: Bahasa Inggris) menjadi representasi vektor matematis, dan Decoder menghasilkan bahasa output (misalnya: Bahasa Indonesia) berdasarkan representasi vektor tersebut.

Gambar berikut menyederhanakan struktur internal dari blok Encoder.

graph TD A["Token Input"] --> B["Input Embedding"] B --> C["Positional Encoding"] C --> D["Multi-Head Self-Attention"] D --> E["Add & Layer Normalization"] E --> F["Feed Forward Network"] F --> G["Add & Layer Normalization"] G --> H["Output ke Layer Berikutnya"] C -.->|"Residual Connection"| E E -.->|"Residual Connection"| G

Mulai dari sini, mari kita ikuti operasi matematis yang dilakukan di setiap komponen langkah demi langkah.

3. Vektorisasi Kata dan Positional Encoding

Komputer tidak dapat memahami teks secara langsung. Teks yang dimasukkan pertama-tama dibagi menjadi unit yang disebut “Token”, dan masing-masing diubah menjadi vektor dengan panjang tetap. Inilah yang disebut Input Embedding.

3.1 Matematika dari Input Embedding

Misalkan ukuran kosa kata (vocabulary) adalah $V$, dan dimensi vektor embedding adalah $d_{model}$ (dalam makalah aslinya $d_{model} = 512$). Setiap kata $w_i$ diubah menjadi vektor $x_i \in \mathbb{R}^{d_{model}}$ menggunakan matriks embedding $W_E \in \mathbb{R}^{V \times d_{model}}$.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Dengan ini, seluruh kalimat direpresentasikan sebagai matriks $X \in \mathbb{R}^{N \times d_{model}}$ (di mana $N$ adalah panjang kalimat).

3.2 Kebutuhan dan Rumus dari Positional Encoding

Transformer tidak memproses kata-kata secara berurutan seperti RNN, melainkan memproses semua kata secara serentak secara paralel. Ini merupakan keuntungan besar dari segi kecepatan komputasi, tetapi pada saat yang sama menimbulkan masalah hilangnya informasi penting tentang “urutan kata”. Misalnya, “Anjing menggigit orang” dan “Orang menggigit anjing” memiliki kumpulan kata input yang sama tetapi maknanya sama sekali berbeda.

Untuk memberikan informasi urutan kata ini kepada model, Positional Encoding dirancang. Positional Encoding $PE$ untuk dimensi ke-$i$ dari kata yang berada di posisi $pos$ dihitung menggunakan fungsi trigonometri berikut.

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Di sini, $pos$ adalah posisi kata ($0, 1, 2, \dots, N-1$), dan $i$ adalah indeks dimensi vektor ($0, 1, \dots, d_{model}/2 - 1$).

Mengapa menggunakan sinus dan kosinus?

Sekilas ini terlihat sebagai rumus yang sangat kompleks dan aneh, tetapi ada alasan matematis yang mendalam untuk hal ini. Dengan menggunakan fungsi trigonometri, model dapat dengan mudah mempelajari bukan hanya “posisi absolut”, melainkan juga selisih “posisi relatif”.

Ingat kembali teorema penjumlahan fungsi trigonometri yang dipelajari dalam matematika sekolah menengah.

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

Positional Encoding dari posisi $pos + k$ yang digeser sejauh offset $k$ dari suatu posisi $pos$ dapat diekspresikan sebagai kombinasi linier dari Positional Encoding posisi $pos$. Artinya, dapat ditulis sebagai berikut dengan menggunakan matriks $M_k$.

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

Berkat ini, mekanisme Attention dapat dengan mudah mengenali jarak relatif “seberapa jauh” antar kata melalui perhitungan perkalian titik (dot product). Selain itu, dengan menggabungkan beberapa gelombang sinus dan kosinus dengan panjang gelombang yang berbeda, ada keuntungan bahwa vektor posisi unik dapat dihasilkan terlepas dari seberapa panjang kalimatnya.

Matriks input akhir $X_{input}$ akan menjadi hasil penjumlahan dari vektor embedding kata dan Positional Encoding ini.

$$ X_{input} = X + PE $$

4. Matematika Mendalam dari Self-Attention (Mekanisme Perhatian Diri)

Akhirnya, kita melangkah ke komponen terpenting dari Transformer, yaitu Self-Attention. Tujuan dari Self-Attention adalah “untuk menghitung tingkat relevansi antara semua kata dalam kalimat, dan memperbarui vektor dari masing-masing kata menjadi representasi yang lebih kaya yang mempertimbangkan konteks”.

Di sini, analogi “sistem pencarian” digunakan.

Query (Q): Kueri (Kata pencarian). “Informasi apa yang sedang saya cari sekarang?”
Key (K): Kunci (Label/Judul). “Informasi apa yang saya miliki?”
Value (V): Nilai (Entitas). “Informasi apa yang sebenarnya saya berikan?”

4.1 Pembuatan Matriks $Q, K, V$

Untuk matriks input $X \in \mathbb{R}^{N \times d_{model}}$ (untuk menyederhanakan, kita abaikan ukuran batch di sini), dengan mengalikannya dengan matriks bobot yang dapat dipelajari $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$, kita menghitung Query $Q$, Key $K$, dan Value $V$. (Biasanya $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Di sini, $Q, K, V$ semuanya menjadi matriks berukuran $\mathbb{R}^{N \times d_k}$.

4.2 Perhitungan Skor Attention (Perkalian Titik/Dot Product)

Untuk mengukur seberapa relevan Query dari setiap kata dengan Key dari semua kata lainnya, kita menghitung perkalian titik (dot product) dari vektor. Jika ditulis dalam operasi matriks, akan menjadi seperti berikut.

$$ \text{Scores} = Q K^T $$

Setiap elemen $s_{ij}$ dari matriks $\text{Scores} \in \mathbb{R}^{N \times N}$ yang diperoleh dari perhitungan ini merepresentasikan perkalian titik antara Query dari kata ke-$i$ dan Key dari kata ke-$j$, yang berarti “tingkat kekuatan relevansi”.

4.3 Penskalaan (Scaling)

Ada satu masalah dengan perhitungan skor menggunakan perkalian titik. Seiring membesarnya dimensi vektor $d_k$, nilai perkalian titik bisa menjadi sangat besar atau sangat kecil.

Mari kita buktikan ini secara matematis. Misalkan setiap elemen kueri $q \sim \mathcal{N}(0, 1)$ dan setiap elemen kunci $k \sim \mathcal{N}(0, 1)$ mengikuti distribusi normal standar yang independen. Kita cari rata-rata dan varians dari perkalian titik $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Rata-rata: Karena $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, rata-rata dari penjumlahan juga $0$. Varians: Varians dari $q_i k_i$ adalah, berdasarkan independensi, $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Oleh karena itu, varians dari keseluruhan perkalian titik sama dengan jumlah dimensi $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Ketika varians menjadi besar, pada fungsi Softmax yang diterapkan setelah ini, gradien selain nilai maksimum akan menjadi sangat kecil sehingga terjadi “vanishing gradient” (gradien menghilang), dan pembelajaran tidak akan mengalami kemajuan. Untuk mencegah hal ini, dengan membagi (menskalakan) skor dengan $\sqrt{d_k}$, kita menjaga agar varians selalu dipertahankan pada $1$.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Probabilisasi dengan Fungsi Softmax

Untuk mengubah skor yang diperoleh menjadi distribusi probabilitas (bobot) yang jumlah totalnya menjadi $1$, fungsi Softmax diterapkan pada setiap baris.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

Matriks $A \in \mathbb{R}^{N \times N}$ ini disebut matriks Attention Weight (Bobot Perhatian). Jika kita melihat setiap baris $i$ dari matriks ini, matriks tersebut mengekspresikan dengan nilai dari 0 hingga 1 tentang “seberapa banyak perhatian (Attention) yang harus diberikan pada kata lain $j$ dalam memahami kata $i$”.

4.5 Penjumlahan Berbobot dari Value

Terakhir, dengan menggunakan matriks Attention Weight $A$ yang diperoleh, kita menghitung penjumlahan berbobot dari matriks Value $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

Matriks $Z \in \mathbb{R}^{N \times d_v}$ yang dihasilkan oleh operasi ini menjadi sekumpulan “representasi vektor kata yang diperbarui dengan mempertimbangkan konteks”. Inilah keseluruhan gambaran dari Scaled Dot-Product Attention yang didefinisikan dalam makalah.

5. Multi-Head Attention (Perhatian Multi-Kepala)

Dengan hanya satu kali perhitungan Attention (Single-Head), ada kemungkinan kita hanya bisa menangkap konteks dari satu sudut pandang saja (misalnya “hubungan tata bahasa”). Oleh karena itu, untuk menangkap berbagai hubungan semantik dan sintaksis yang dimiliki bahasa (“subjek dan predikat”, “kata ganti dan rujukan panggilannya”, dll.) secara bersamaan, Multi-Head Attention diperkenalkan.

Pembentukan $Q, K, V$ dan perhitungan Attention seperti sebelumnya dilakukan sebanyak $h$ kali secara paralel (jumlah kepala. Dalam makalah aslinya $h=8$).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Di sini, $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ adalah matriks bobot yang dapat dipelajari khusus untuk kepala (head) ke-$i$.

Hasil $\text{head}_i \in \mathbb{R}^{N \times d_v}$ yang dikeluarkan dari setiap kepala digabungkan (Concatenate) secara horizontal.

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Biasanya diatur agar $h \cdot d_v = d_{model}$, sehingga dimensi setelah digabungkan kembali menjadi $d_{model}$ yang sama seperti input. Terakhir, matriks ini dikalikan dengan matriks bobot $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ untuk mendapatkan output akhir.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Input X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Head 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Head 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Head h"] H1 & H2 & HN --> C["Concatenate"] C --> WO["Kalikan dengan WO"] WO --> OUT["Output Multi-Head"]

6. Feed-Forward Neural Network (FFN)

Output dari Multi-Head Attention selanjutnya dimasukkan ke dalam Position-wise Feed-Forward Network (FFN). Ini adalah jaringan saraf terhubung penuh (fully connected neural network) 2 lapis yang diterapkan “secara independen untuk setiap posisi (kata)” dalam deretan.

Jika diekspresikan dengan rumus matematika, bentuknya adalah sebagai berikut.

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Di sini, $\max(0, z)$ mewakili fungsi aktivasi ReLU (Rectified Linear Unit) (dalam model-model terbaru, GELU atau SwiGLU sering digunakan).

Peran dari jaringan ini sangatlah penting. Mekanisme Attention mempelajari “hubungan antarkata (hubungan spasial/sekuensial)”, sedangkan FFN bertanggung jawab atas “transformasi fitur non-linier dari setiap vektor kata itu sendiri”. Biasanya, dimensi untuk sementara diperluas sangat besar oleh bobot $W_1$ di lapisan pertama (misalnya, diperbesar 4 kali dari $d_{model}=512$ menjadi $d_{ff}=2048$), melakukan perhitungan kompleks pada ruang fitur, dan kemudian dikembalikan ke dimensi aslinya di lapisan kedua dengan bobot $W_2$. Dengan “perluasan dan penyusutan dimensi” ini, daya ekspresi model meningkat secara dramatis.

7. Residual Connection dan Layer Normalization

Dalam deep learning, saat kita membuat lapisan jaringan semakin dalam, seringkali muncul masalah di mana gradien menghilang (vanishing) atau meledak (exploding) selama pembelajaran, sehingga model tidak dapat belajar dengan baik. Untuk mencegah hal ini, Residual Connection (Koneksi Residu) dan Layer Normalization (Normalisasi Lapisan) ditempatkan di sekitar setiap sub-lapisan (Attention dan FFN) dari Transformer.

Jika ditulis dalam rumus, output dari sub-lapisan diproses sebagai berikut.

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Residual Connection ($x + \text{Sublayer}(x)$)

Input $x$ ditambahkan langsung ke output sub-lapisan. Dengan ini, selama propagasi balik (backpropagation), gradien ditransmisikan langsung ke lapisan dangkal melalui jalan pintas, sehingga pembelajaran menjadi stabil meskipun lapisannya dalam.

7.2 Matematika Layer Normalization

Layer Normalization adalah teknologi untuk menghitung rata-rata dan varians di sepanjang arah dimensi fitur dan menormalisasi data. Untuk input dengan ukuran batch $B$, panjang urutan $N$, dan jumlah dimensi $d_{model}$, normalisasi dilakukan untuk salah satu vektor kata $x \in \mathbb{R}^{d_{model}}$.

Rata-rata $\mu$ dan varians $\sigma^2$ dihitung.

$$ \mu = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} x_i $$ $$ \sigma^2 = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} (x_i - \mu)^2 $$

Kemudian, output yang dinormalisasi $\hat{x}$ diperoleh.

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

($\epsilon$ adalah konstanta yang sangat kecil untuk mencegah pembagian dengan nol. $\gamma, \beta$ adalah parameter skala dan pergeseran yang dapat dipelajari)

Alasan mengapa normalisasi pada arah lapisan (Layer Normalization) diadopsi, alih-alih normalisasi arah batch (Batch Normalization), adalah karena ketika memproses data deret (sekuensial) yang panjangnya tidak konstan seperti kalimat, statistik antar batch cenderung menjadi tidak stabil. Dengan Layer Normalization, Transformer dapat belajar dengan stabil tanpa bergantung pada ukuran batch.

8. Struktur Khusus Decoder: Masked Attention dan Cross-Attention

Struktur yang telah dijelaskan sejauh ini adalah milik Encoder. Pada blok Decoder yang menghasilkan teks, strukturnya sedikit berbeda.

8.1 Masked Multi-Head Attention

Peran dari Decoder adalah “untuk memprediksi kata berikutnya dari kata-kata di masa lalu”. Oleh karena itu, jika model melihat “kata di masa depan” selama pelatihan, itu sama saja dengan menyontek. Operasi matematis untuk mencegah hal ini adalah Masking (Penyamaran/Pemaskeran).

Ke dalam matriks skor $Q K^T$, sebuah matriks mask $M$ yang mengatur nilai yang sangat kecil mendekati $-\infty$ pada bagian segitiga atas (mewakili informasi di masa depan) ditambahkan.

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

Saat menghitung fungsi Softmax, karena $\exp(-\infty) = 0$, nilai Attention Weight ke kata di masa depan akan benar-benar menjadi $0$. Hal ini memungkinkan pembangkitan auto-regresif dengan mempertahankan hubungan sebab akibat (Causality).

8.2 Encoder-Decoder Cross-Attention

Sub-lapisan kedua dari Decoder adalah Cross-Attention yang merujuk pada output dari Encoder. Di sini, $Q$ dihasilkan dari lapisan Decoder sebelumnya, tetapi $K$ dan $V$ dihasilkan dari output lapisan akhir Encoder.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

Berkat perhitungan ini, dalam tugas seperti terjemahan, model dapat belajar tentang “bagian mana dari kalimat bahasa asing asli yang sangat terkait dengan kata yang sedang diterjemahkan”.

9. Kompleksitas Komputasi dan Matematika Optimasi Modern

Transformer adalah model yang luar biasa, tetapi ada juga “kelemahan” karena struktur matematisnya. Perhatikan kompleksitas perhitungan dari Self-Attention. Dalam penghitungan matriks skor $Q K^T$, sebuah matriks berukuran $(N \times d_k)$ dan matriks $(d_k \times N)$ dikalikan, sehingga kompleksitas perhitungannya adalah $O(N^2 \cdot d_{model})$.

Artinya, kompleksitas komputasi dan penggunaan memori meningkat secara kuadratik seiring dengan panjang urutan $N$. Ini tidak masalah untuk kalimat pendek, tetapi jika Anda mencoba memasukkan konteks yang sangat panjang seperti keseluruhan buku ke dalam LLM, maka nilai $N$ bisa mencapai puluhan ribu hingga ratusan ribu, dan memori GPU akan segera habis dengan perhitungan Attention konvensional.

Untuk memecahkan kutukan $O(N^2)$ ini, berbagai optimalisasi telah diusulkan dalam beberapa tahun terakhir dari pendekatan perangkat keras maupun matematis. Contoh perwakilannya adalah FlashAttention. FlashAttention adalah algoritma yang melakukan perhitungan Attention dengan membaginya menjadi bentuk ubin (Tiling) sedemikian rupa untuk meminimalkan transfer data (akses memori) antara hierarki memori GPU (SRAM dan HBM). Meskipun secara matematis mengeluarkan hasil yang persis sama dengan Attention standar (Exact Attention), optimalisasi tingkat perangkat keras ini menghasilkan peningkatan kecepatan dan pengurangan memori yang drastis, sehingga memungkinkan terwujudnya model konteks panjang seperti GPT-4.

Selain itu, penelitian seperti Sparse Attention dan Linear Attention yang memperkirakan (mengaproksimasi) kompleksitas komputasi menjadi $O(N \log N)$ atau $O(N)$ juga sedang gencar dilakukan.

10. Gambaran Implementasi (Pseudocode bergaya PyTorch)

Jika struktur matematis sejauh ini dituangkan ke dalam kode pemrograman yang sebenarnya (Python / PyTorch), Anda akan menyadari bahwa strukturnya dapat ditulis dengan sangat sederhana. Berikut adalah kode semu (pseudocode) dari bagian inti Self-Attention.

 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


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # bentuk q, k, v: [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Perhitungan skor dengan perkalian titik: Q * K^T
 # Menghitung perkalian matriks dengan mentranspos dua dimensi terakhir
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Penskalaan (Scaling)
 scores = scores / math.sqrt(d_k)

 # 3. Masking (Dalam hal Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Probabilisasi dengan Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Mengalikan dengan matriks Value
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Dapat dilihat bahwa rumus matematika $Q K^T / \sqrt{d_k}$ diimplementasikan secara intuitif sebagai torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k). Fakta bahwa teori matematika diwujudkan dalam beberapa baris kode dengan bantuan perpustakaan (library) optimasi tingkat lanjut adalah salah satu aspek yang sangat menarik dari deep learning.

Penutup: Bentuk “Kecerdasan” yang Terlihat dari Rumus Matematika

Dalam artikel ini, kita telah menguraikan struktur matematis di kedalaman model Transformer.

Embedding yang memetakan kata ke dalam ruang vektor multidimensi, Positional Encoding yang mengekspresikan informasi posisi melalui sintesis gelombang trigonometri, dan mekanisme Self-Attention yang merupakan perhitungan perkalian titik matriks yang lahir dari analogi temu balik informasi. Masing-masing komponen ini hanyalah akumulasi dari matematika dasar seperti aljabar linier, kalkulus, dan probabilitas & statistik.

Namun, ketika operasi matriks sederhana ini ditumpuk menjadi banyak lapisan dan mempelajari pola dari kumpulan data raksasa melalui miliaran bahkan triliunan parameter, di sanalah muncul sebuah “bentuk kecerdasan” yang seolah-olah mampu memahami “kata-kata” kita, melakukan inferensi logis, dan terkadang menghasilkan ide-ide kreatif.

Seperti judul provokatif “Attention Is All You Need”, keindahan dari arsitektur yang membuang pemrosesan recurrent yang rumit maupun pemrosesan konvolusional dan berfokus murni pada perhitungan “Attention” (tingkat relevansi) ini, bisa dikatakan justru terletak pada kesederhanaan matematisnya.

Di masa depan, mungkin akan muncul arsitektur baru yang melampaui Transformer (seperti Mamba yang merupakan State Space Model), tetapi kerangka kerja matematis “pemahaman konteks oleh Attention” yang dibangun oleh Transformer pasti akan terukir selamanya dalam sejarah AI.

Jika Anda memiliki kesempatan untuk menggunakan LLM seperti ChatGPT atau Claude di masa mendatang, cobalah bayangkan bahwa di latar belakangnya terdapat triliunan kali perkalian matriks $Q K^T$ yang dihitung setiap detiknya, dan fungsi Softmax yang memunculkan probabilitas-probabilitasnya. Pemahaman (resolusi) terhadap teknologi ini akan meningkat, dan dunia AI akan terasa jauh lebih menarik bagi Anda.

Referensi

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Artikel ini ditulis sebagai panduan bagi mereka yang mempelajari pemrosesan bahasa alami dan dasar matematis dari AI. Jika Anda memiliki pertanyaan atau ingin berdiskusi, silakan beri tahu di kolom komentar!

Dasar dan Implementasi Kriptografi Menggunakan Teorema Kecil Fermat

Fri, 11 Sep 2026 22:00:00 +0900

1. Pendahuluan: Misteri Matematika yang Mendukung Kriptografi Modern

Dalam masyarakat digital modern, khususnya dalam komunikasi melalui internet, “kriptografi” (enkripsi) telah menjadi teknologi dasar yang sangat penting. Kemampuan kita untuk menjelajahi situs web dengan aman melalui HTTPS di peramban, melakukan transaksi keuangan melalui perbankan daring, dan bertukar pesan pribadi di aplikasi perpesanan, semuanya dimungkinkan karena adanya protokol kriptografi yang didukung oleh teori matematika tingkat tinggi yang bekerja di latar belakang. Di antaranya, “kriptografi kunci publik” memainkan peran yang sangat penting, dan perwakilan utamanya adalah Kriptografi RSA.

Keamanan dan keabsahan banyak algoritma kriptografi, termasuk kriptografi RSA, sangat bergantung pada teorema yang sangat indah dan kuat yang ditemukan oleh ahli matematika Prancis abad ke-17, Pierre de Fermat. Itulah Teorema Kecil Fermat (Fermat’s Little Theorem). Selanjutnya, Teorema Euler dari Leonhard Euler, yang merupakan generalisasi dari teorema ini, juga memainkan peran penting dalam teori kriptografi.

Artikel ini akan membahas secara mendalam dari dasar bagaimana penemuan matematika murni berupa Teorema Kecil Fermat diterapkan pada teknologi kriptografi praktis modern, khususnya dalam “pengujian primalitas” (primality test) dan “kriptografi RSA”. Ini adalah panduan teknis yang sangat rinci yang mencakup pembuktian matematika, mekanisme enkripsi dan dekripsi, serta implementasi algoritma spesifik menggunakan C++ dan Python.

2. Dasar-dasar Kongruensi dan Aritmetika Modular

Untuk memahami Teorema Kecil Fermat, pertama-tama kita perlu membiasakan diri dengan konsep matematika yang disebut “aritmetika modular” (kekongruenan). Aritmetika modular adalah sistem perhitungan yang berfokus pada “sisa” ketika dibagi dengan bilangan tertentu yang tetap (disebut modulus). Karena perhitungannya mirip dengan tampilan jam (yang berputar kembali setiap 12 jam), ini sering juga disebut “matematika jam”.

Ketika bilangan bulat $a$ dan $b$ memiliki sisa yang sama saat dibagi dengan bilangan bulat positif $n$, secara matematis ditulis sebagai berikut:

$$ a \equiv b \pmod n $$

Ini dibaca “$a$ dan $b$ kongruen dalam modulo $n$”. Misalnya, sisa dari 17 dibagi 5 adalah 2, dan sisa dari 12 dibagi 5 juga 2. Oleh karena itu, kita dapat menulisnya sebagai berikut:

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

Dalam aritmetika modular, empat operasi aritmetika dasar (penjumlahan, pengurangan, perkalian) berlaku seperti biasa.

Penjumlahan: Jika $a \equiv b \pmod n$ dan $c \equiv d \pmod n$, maka $a + c \equiv b + d \pmod n$
Pengurangan: Jika $a \equiv b \pmod n$ dan $c \equiv d \pmod n$, maka $a - c \equiv b - d \pmod n$
Perkalian: Jika $a \equiv b \pmod n$ dan $c \equiv d \pmod n$, maka $a \times c \equiv b \times d \pmod n$
Perpangkatan: Jika $a \equiv b \pmod n$, maka untuk sembarang bilangan asli $k$, $a^k \equiv b^k \pmod n$

Namun, perlu berhati-hati mengenai pembagian. Secara umum, meskipun $a \times c \equiv b \times c \pmod n$, kita tidak bisa begitu saja membagi kedua ruas dengan $c$ untuk mendapatkan $a \equiv b \pmod n$. Hal ini hanya berlaku jika $c$ dan $n$ saling prima (faktor persekutuan terbesarnya adalah 1). Konsep “invers modular” ini akan menjadi sangat penting dalam pembuatan kunci untuk kriptografi RSA yang akan dibahas nanti.

3. Latar Belakang Matematika dan Pembuktian Teorema Kecil Fermat

Setelah memahami dasar-dasar aritmetika modular, mari kita lihat Teorema Kecil Fermat yang menjadi topik utama.

3.1 Definisi Teorema

Teorema Kecil Fermat dirumuskan sebagai berikut:

Teorema Kecil Fermat (Fermat’s Little Theorem) Misalkan $p$ adalah bilangan prima dan $a$ adalah sembarang bilangan bulat yang bukan kelipatan $p$ (yaitu $a$ dan $p$ saling prima). Maka, persamaan kongruensi berikut berlaku:
$$ a^{p-1} \equiv 1 \pmod p $$

Secara umum, ini juga sering direpresentasikan dengan menghilangkan syarat “$a$ bukan kelipatan $p$” sehingga berlaku untuk semua bilangan bulat $a$. Dalam hal ini, kedua ruas dikalikan dengan $a$ menjadi:

$$ a^p \equiv a \pmod p $$

3.2 Konfirmasi dengan Contoh Spesifik

Mari kita periksa apakah teorema ini benar-benar berlaku menggunakan angka-angka spesifik. Misalkan bilangan prima $p = 5$. Maka $p-1 = 4$. Kita pilih sembarang bilangan bulat $a$ yang bukan kelipatan $p$.

Untuk $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ sisa $1$. Jadi $16 \equiv 1 \pmod 5$. (Berlaku)
Untuk $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ sisa $1$. Jadi $81 \equiv 1 \pmod 5$. (Berlaku)
Untuk $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ sisa $1$. Jadi $256 \equiv 1 \pmod 5$. (Berlaku)

Dengan cara ini, tidak peduli berapa nilai $a$ yang dipilih (asalkan bukan kelipatan 5), jika dipangkatkan 4 lalu dibagi 5, sisanya pasti 1. Terlihat seperti sulap, tetapi ini berasal dari sifat indah yang dimiliki bilangan prima.

3.3 Pembuktian Matematika dari Teorema

Mengapa hal ini bisa terjadi? Di sini kita akan memperkenalkan pembuktian elegan menggunakan himpunan kelas residu.

Pertimbangkan himpunan $S = \{1, 2, 3, \dots, p-1\}$. Ini adalah elemen perwakilan dari bilangan bulat yang memiliki sisa $1$ hingga $p-1$ jika dibagi dengan $p$. Sekarang, pertimbangkan himpunan baru $T$ di mana setiap elemen dikalikan dengan bilangan bulat $a$ yang saling prima dengan $p$.

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

Mari kita pertimbangkan sisa dari setiap elemen di himpunan $T$ ketika dibagi dengan $p$. Hebatnya, meskipun urutannya mungkin berubah, himpunan sisa-sisa ini persis sama dengan himpunan elemen asli $S$. Mengapa:

Tidak ada elemen di $T$ yang menjadi kelipatan $p$ (karena baik $a$ maupun elemen aslinya bukan kelipatan $p$).
Tidak ada dua elemen berbeda di $T$ yang kongruen modulo $p$. Jika $ia \equiv ja \pmod p$ ($i \neq j$), karena $a$ dan $p$ saling prima, kita dapat membagi kedua ruas dengan $a$, sehingga didapat $i \equiv j \pmod p$ yang mana ini adalah kontradiksi.

Oleh karena itu, hasil kali semua elemen di $S$ dan hasil kali semua elemen di $T$ akan kongruen dalam modulo $p$.

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

Jika kita menyederhanakan ruas kiri, karena terdapat $a$ sebanyak $p-1$ buah,

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

Karena $(p-1)!$ saling prima dengan $p$, kita dapat membagi kedua ruas dengan $(p-1)!$, dan pada akhirnya menghasilkan teorema berikut.

$$ a^{p-1} \equiv 1 \pmod p $$

Inilah pembuktian Teorema Kecil Fermat.

4. Fungsi Totient Euler dan Teorema Euler

Teorema Kecil Fermat adalah teorema tentang “bilangan prima $p$”, namun Leonhard Euler menggeneralisasinya menjadi berlaku untuk “sembarang bilangan bulat positif $n$”. Generalisasi ini sangat penting untuk memahami kriptografi RSA.

4.1 Fungsi Totient Euler $\phi(n)$

Fungsi Totient Euler (atau fungsi $\phi$ Euler) $\phi(n)$ adalah fungsi yang menyatakan “jumlah bilangan bulat dari $1$ hingga $n$ yang saling prima dengan $n$”.

Untuk bilangan prima $p$, karena semua bilangan dari $1$ hingga $p-1$ saling prima dengan $p$, maka $\phi(p) = p - 1$.
Untuk dua bilangan prima berbeda $p, q$, pada hasil kalinya $n = p \times q$, $\phi(n)$ dapat dicari dengan rumus yang sangat sederhana. $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Sifat ini menjadi logika inti dalam pembuatan kunci kriptografi RSA.

4.2 Teorema Euler

Euler menggeneralisasi Teorema Kecil Fermat sebagai berikut:

Teorema Euler (Euler’s Theorem) Untuk bilangan bulat positif $n$ dan bilangan bulat $a$ yang saling prima dengannya, berlaku persamaan berikut:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Jika $n$ adalah bilangan prima $p$, karena $\phi(p) = p - 1$, ini menjadi tepat sama dengan Teorema Kecil Fermat ($a^{p-1} \equiv 1 \pmod p$). Dengan kata lain, Teorema Kecil Fermat hanyalah kasus khusus dari Teorema Euler.

5. Menemukan Bilangan Prima Raksasa: Uji Primalitas Fermat

Dalam teknologi kriptografi (seperti RSA dan pertukaran kunci Diffie-Hellman), kita perlu menemukan “bilangan prima raksasa” yang panjangnya bisa mencapai ratusan digit dengan sangat cepat. Namun, untuk menentukan apakah sebuah angka besar $N$ adalah bilangan prima, menggunakan metode “uji pembagian” yang mencoba membagi angka tersebut dengan semua bilangan dari $2$ hingga $\sqrt{N}$ akan memakan waktu selama umur alam semesta.

Oleh karena itu, muncul “metode uji primalitas probabilistik” yang memanfaatkan Teorema Kecil Fermat, yaitu Uji Fermat (Fermat Primality Test).

5.1 Apa itu Uji Primalitas Probabilistik?

Menurut Teorema Kecil Fermat, jika $p$ adalah bilangan prima, maka untuk sembarang $a$ ($1 < a < p$), $a^{p-1} \equiv 1 \pmod p$ pasti berlaku. Berdasarkan kontraposisinya, kita dapat menyatakan bahwa “jika untuk suatu $a$ berlaku $a^{p-1} \not\equiv 1 \pmod p$, maka $p$ pasti bukan bilangan prima (merupakan bilangan komposit)”.

Dengan demikian, jika kita ingin menguji apakah $N$ adalah bilangan prima, kita memilih beberapa $a$ secara acak, menghitung $a^{N-1} \pmod N$, dan memeriksa apakah hasilnya $1$. Jika setidaknya satu kali menghasilkan selain $1$, maka dipastikan $N$ adalah bilangan komposit. Jika hasilnya selalu $1$ tak peduli berapa kali kita mencoba, kita dapat menyimpulkan dengan probabilitas tinggi bahwa $N$ “kemungkinan besar adalah bilangan prima”.

5.2 Penjelasan Algoritma dan Diagram Alur

Algoritma Uji Fermat adalah sebagai berikut:

flowchart TD Start["Mulai"] --> Input["Masukkan angka yang akan diuji p dan jumlah uji coba k"] Input --> LoopStart["Looping dari i = 0 hingga k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Ya" --> RandomA["Pilih bilangan acak a dalam rentang 1 < a < p-1"] RandomA --> Calc["Hitung eksponensiasi modular a^(p-1) mod p"] Calc --> CheckPrime{"Apakah hasilnya 1?"} CheckPrime -- "Tidak" --> ReturnComposite["p adalah bilangan komposit (pasti)"] CheckPrime -- "Ya" --> Increment["Tingkatkan nilai i"] Increment --> Condition Condition -- "Tidak" --> ReturnPrime["p kemungkinan besar bilangan prima (probabilistik)"] ReturnComposite --> End["Selesai"] ReturnPrime --> End

5.3 Perangkap Bilangan Carmichael (Bilangan Prima Semu)

Meskipun Uji Fermat sangat cepat, ada kelemahan fatal. Terdapat bilangan komposit bagaikan iblis yang tetap memenuhi $a^{N-1} \equiv 1 \pmod N$ untuk semua nilai $a$. Angka ini disebut Bilangan Carmichael (Carmichael numbers). Bilangan Carmichael terkecil adalah $561$ ($3 \times 11 \times 17$).

Karena adanya bilangan Carmichael, kita tidak bisa melakukan uji primalitas yang mutlak hanya dengan Uji Fermat murni. Oleh karena itu, dalam sistem kriptografi nyata (seperti OpenSSL), standar yang digunakan adalah modifikasi dari Uji Fermat, yaitu Uji Primalitas Miller-Rabin. Uji Miller-Rabin mampu mendeteksi bilangan Carmichael sehingga dapat menekan probabilitas kesalahan identifikasi hingga mendekati nol secara praktis.

5.4 Eksponensiasi Modular Cepat (Metode Penguadratan Berulang)

Dalam algoritma uji primalitas, kita perlu menghitung $a^{N-1} \pmod N$. Jika $N$ sangat besar, jumlah digit $a^{N-1}$ akan menjadi angka astronomis yang tidak muat dalam memori komputer. Solusi untuk masalah ini adalah Metode Penguadratan Berulang (Exponentiation by Squaring) atau operasi eksponensiasi modular. Dengan mengambil sisa (mod N) pada setiap langkah perhitungan, nilainya selalu dijaga lebih kecil dari $N$, sehingga perhitungan dapat diselesaikan dengan sangat cepat (kompleksitas waktu $O(\log N)$).

6. Implementasi Uji Primalitas dan Eksponensiasi Modular

Sekarang mari kita coba mengimplementasikan Uji Primalitas Fermat dan metode penguadratan berulang dalam C++ dan Python.

6.1 Implementasi dengan C++

Di C++, tipe integer standar mudah mengalami overflow, sehingga pustaka integer presisi ganda (seperti GMP) diperlukan untuk menangani angka besar. Namun di sini, untuk memahami algoritmanya, kita akan menunjukkannya dalam batas integer 64-bit (unsigned long long).

 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


#include <iostream>
#include <random>

using namespace std;

// Eksponensiasi modular cepat (a^b mod m) - Metode penguadratan berulang
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Jika bit terendah dari b adalah 1, kalikan hasilnya dengan a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Ekspansi ke 128-bit untuk mencegah overflow
 }
 // Kuadratkan a
 a = (__int128)a * a % m;
 // Geser b ke kanan (bagi dua)
 b /= 2;
 }
 return result;
}

// Uji Primalitas Fermat
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Jika a^(p-1) mod p bukan 1, maka itu bilangan komposit
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Kemungkinan besar prima
}

int main() {
 unsigned long long num = 1000000007; // Bilangan prima yang diketahui
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Implementasi dengan Python

Tipe integer standar pada Python mendukung presisi ganda, jadi kita tidak perlu khawatir akan terjadinya overflow. Selain itu, fungsi bawaan Python pow(a, b, m) secara internal menggunakan metode penguadratan berulang sehingga sangat cepat.

 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


import random

def fermat_is_prime(p, iterations=5):
 """
 Uji primalitas probabilistik menggunakan Uji Primalitas Fermat
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Pilih angka acak a antara 2 hingga p-2
 a = random.randint(2, p - 2)
 # Hitung a^(p-1) mod p. Fungsi bawaan pow sangat cepat.
 if pow(a, p - 1, p) != 1:
 return False # Pasti komposit

 return True # Kemungkinan besar prima

# Uji Coba
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} kemungkinan besar adalah bilangan prima.")
else:
 print(f"{number_to_test} adalah bilangan komposit.")

7. Penerapan pada Kriptografi RSA: Tempat Fermat dan Euler Membuahkan Hasil

Penerapan paling hebat dari Teorema Kecil Fermat (dan Teorema Euler) adalah Kriptografi RSA, yang dikembangkan pada tahun 1977 oleh Rivest, Shamir, dan Adleman. Kriptografi RSA adalah sistem “kriptografi kunci publik” yang revolusioner, di mana kunci untuk mengenkripsi (kunci publik) dipublikasikan ke seluruh dunia, sementara kunci untuk mendekripsi (kunci privat) hanya diketahui oleh penerima.

Asimetri ini didasarkan pada keamanan komputasional bahwa “memfaktorkan bilangan komposit raksasa menjadi faktor primanya adalah hal yang sangat sulit”.

7.1 Mekanisme Kriptografi RSA (Pembuatan Kunci, Enkripsi, Dekripsi)

Mari kita periksa keseluruhan alur komunikasi pada kriptografi RSA menggunakan diagram sekuens Mermaid.

sequenceDiagram participant Alice["Alice (Penerima)"] participant Bob["Bob (Pengirim)"] Alice->>Alice: "Hasilkan bilangan prima raksasa p, q" Alice->>Alice: "Hitung N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Hitung kunci publik e dan kunci privat d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Kirim kunci publik (N, e)" Note over Bob: "Siapkan teks terang M (M < N)" Bob->>Bob: "Hitung teks sandi C = M^e mod N" Bob->>Alice: "Kirim teks sandi C" Alice->>Alice: "Dekripsi dengan menghitung teks terang M = C^d mod N"

Berikut adalah penjelasan langkah-langkah detail secara matematis.

Langkah 1: Pembuatan Kunci (Tugas Alice sebagai Penerima)

Hasilkan secara acak dua bilangan prima raksasa $p$ dan $q$ (di sini metode uji primalitas sebelumnya digunakan).
Hitung hasil kalinya, $N = p \times q$. Nilai $N$ ini akan dipublikasikan.
Gunakan Fungsi Totient Euler untuk menghitung $\phi(N) = (p-1)(q-1)$.
Pilih bilangan bulat $e$ (eksponen publik) yang saling prima dengan $\phi(N)$ (sering kali $e = 65537$ digunakan).
Hitung invers modular $d$ (eksponen privat) dari $e$. Dengan kata lain, temukan $d$ yang memenuhi: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Perhitungan ini menggunakan Algoritma Euclidean Diperluas (Extended Euclidean algorithm).

Sekarang, Kunci Publiknya adalah $(N, e)$, dan Kunci Privatnya adalah $(N, d)$. ($p, q, \phi(N)$ harus segera dimusnahkan atau disembunyikan dengan ketat).

Langkah 2: Enkripsi (Tugas Bob sebagai Pengirim)

Misalkan Bob ingin mengirim pesan $M$ ke Alice ($M$ adalah angka hasil konversi karakter, dan $0 \le M < N$). Bob menggunakan kunci publik Alice $(N, e)$ untuk membuat teks sandi $C$ dengan perhitungan berikut.

$$ C \equiv M^e \pmod N $$

Bob kemudian mengirimkan $C$ ini kepada Alice melalui jaringan.

Langkah 3: Dekripsi (Tugas Alice sebagai Penerima)

Setelah menerima teks sandi $C$, Alice yang merupakan satu-satunya orang yang mengetahui kunci privat $d$, melakukan perhitungan berikut.

$$ M' \equiv C^d \pmod N $$

Menariknya, hasil perhitungan $M'$ ini persis sama dengan pesan asli $M$.

7.2 Mengapa Dapat Didekripsi? (Pembuktian Matematika)

Di sinilah nilai sebenarnya dari Teorema Kecil Fermat (Teorema Euler) terlihat. Mengapa $C^d \pmod N$ bisa kembali menjadi $M$?

Mari kita jabarkan rumus dekripsinya. Karena $C \equiv M^e \pmod N$, maka:

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

Pada langkah pembuatan kunci, kita memilih $d$ sedemikian rupa sehingga $e \cdot d \equiv 1 \pmod{\phi(N)}$. Ini berarti bahwa ada suatu bilangan bulat $k$ sehingga dapat ditulis sebagai berikut:

$$ e \cdot d = 1 + k \cdot \phi(N) $$

Substitusikan ini ke dalam persamaan sebelumnya.

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

Di sini Teorema Euler ($M^{\phi(N)} \equiv 1 \pmod N$) berperan. (Secara ketat, $M$ dan $N$ harus saling prima, tetapi dalam RSA, probabilitas $M$ dan $N$ tidak saling prima sangatlah kecil secara astronomis, dan menggunakan Teorema Sisa Tiongkok (Chinese Remainder Theorem) dapat dibuktikan bahwa ini tetap berlaku meskipun tidak saling prima).

Dengan menerapkan Teorema Euler, karena $M^{\phi(N)} \equiv 1$, maka:

$$ M \cdot (1)^k \equiv M \pmod N $$

Luar biasa, $M$ berhasil dipulihkan! Sifat angka yang ditemukan oleh Fermat dan Euler berabad-abad lalu mampu memberikan jaminan kerahasiaan komunikasi digital modern secara sempurna.

8. Implementasi Mainan Kriptografi RSA (Python)

Karena hanya belajar teori rasanya belum lengkap, mari kita coba mengimplementasikan proses pembuatan kunci, enkripsi, dan dekripsi RSA secara langsung menggunakan Python. Ini hanyalah “implementasi mainan (toy)” untuk tujuan edukasi, tetapi matematika yang digunakan sama persis dengan aslinya.

Kita juga akan menyertakan implementasi “Algoritma Euclidean Diperluas” untuk mencari invers modular $d$.

 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


import random

# Mencari Faktor Persekutuan Terbesar (FPB)
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Algoritma Euclidean Diperluas (Mencari x, y untuk ax + by = gcd(a,b))
# Digunakan untuk mencari d pada e*d ≡ 1 (mod φ(N))
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('Invers modular tidak ada')
 else:
 return x % phi

# Fungsi pembuat bilangan prima (Versi sederhana: membuat bilangan prima kecil)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Pemeriksaan sederhana sebagai pengganti Uji Fermat sebelumnya
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Pembuatan Kunci RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Pastikan p dan q tidak sama
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # e umumnya menggunakan bilangan prima seperti 65537, tetapi di sini dipilih secara acak
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Perhitungan kunci privat d
 d = mod_inverse(e, phi)

 # Kunci Publik (e, n), Kunci Privat (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # Hitung plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # Hitung cipher^d mod n, lalu ubah kembali menjadi karakter
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Contoh Eksekusi
if __name__ == '__main__':
 print("--- Implementasi Mainan Kriptografi RSA ---")
 public_key, private_key = generate_keypair(bits=12) # Menggunakan bilangan prima 12-bit

 print(f"Kunci Publik (e, n): {public_key}")
 print(f"Kunci Privat (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nPesan asli: {message}")

 # Enkripsi
 encrypted_msg = encrypt(public_key, message)
 print(f"Teks Sandi: {encrypted_msg}")

 # Dekripsi
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Pesan yang Didekripsi: {decrypted_msg}")

Jika Anda menjalankan kode ini, Anda dapat melihat array karakter diubah menjadi array angka asing (teks sandi), yang kemudian berhasil dikembalikan menjadi string aslinya menggunakan kunci privat.

9. Penutup: Titik Temu Keindahan dan Kepraktisan Matematika

Pada abad ke-17 ketika Pierre de Fermat menemukan “Teorema Kecil” ini, tidak ada yang berpikir bahwa ini akan berguna untuk sesuatu. Fermat sendiri melakukan penelitian pada teori bilangan murni karena rasa ingin tahunya terhadap matematika.

Namun, sekitar 300 tahun kemudian, pada era awal jaringan komputer di tahun 1970-an, Teorema Fermat dibangkitkan kembali secara dramatis sebagai teknologi kriptografi yang mutlak diperlukan untuk membangun protokol komunikasi yang aman. Teknologi uji primalitas yang didasarkan pada Teorema Kecil Fermat dan kriptografi RSA yang didasarkan pada Teorema Euler, benar-benar menjadi pilar yang menopang infrastruktur internet modern.

Pesan LINE yang kita kirimkan tanpa berpikir setiap harinya, atau belanja yang kita lakukan di Amazon, semuanya menari di atas persamaan matematika yang indah dan sederhana: $a^{p-1} \equiv 1 \pmod p$. Teorema Kecil Fermat mengajarkan kita bahwa betapa pun abstraknya sebuah konsep matematika, suatu saat nanti ia pasti akan berguna bagi umat manusia.

Dalam mempelajari pemrograman dan teori kriptografi, memahami struktur matematika yang menjadi dasarnya akan menjadi senjata yang ampuh untuk memahami secara mendalam cara kerja perpustakaan (library) perangkat lunak yang disajikan sebagai kotak hitam, dan untuk merancang sistem yang lebih aman.

Intuisi Matematis Kriptografi Berbasis Kisi (Lattice-based cryptography)

Fri, 11 Sep 2026 21:00:00 +0900

1. Pendahuluan: Fajar Kriptografi Pasca-Kuantum (PQC) dan Bangkitnya Kriptografi Berbasis Kisi

Infrastruktur digital masyarakat modern saat ini ditopang oleh teknologi kriptografi kunci publik seperti kriptografi RSA dan kriptografi kurva eliptik (ECC). Metode kriptografi ini mendasarkan keamanannya pada kesulitan matematis seperti “masalah faktorisasi bilangan bulat” dan “masalah logaritma diskrit”, yang diyakini tidak dapat dipecahkan secara efisien (membutuhkan waktu eksponensial) oleh komputer klasik konvensional.

Namun, “Algoritma Shor” yang diterbitkan oleh Peter Shor pada tahun 1994, mengirimkan gelombang kejut ke dunia kriptografi. Algoritma ini secara matematis membuktikan bahwa ketika komputer kuantum skala besar terwujud, komputer tersebut akan dapat menyelesaikan masalah faktorisasi bilangan bulat dan masalah logaritma diskrit dalam waktu polinomial. Ini berarti bahwa kriptografi kunci publik yang digunakan secara luas saat ini akan dapat dipecahkan sepenuhnya di masa depan.

Untuk melawan “Ancaman Kuantum (Quantum Threat)” ini, penelitian tentang metode kriptografi baru yang sulit dipecahkan bahkan menggunakan komputer kuantum telah menjadi kebutuhan mendesak. Bidang ini disebut “Kriptografi Pasca-Kuantum (Post-Quantum Cryptography: PQC)”.

Ada beberapa kandidat kuat untuk PQC. Kriptografi berbasis hash, kriptografi berbasis kode, kriptografi polinomial multivariat, kriptografi isogeni, dan lain-lain dapat disebutkan, tetapi di antara semuanya, yang paling menarik perhatian saat ini dan menjadi pusat proses standardisasi PQC oleh NIST (Institut Standar dan Teknologi Nasional AS) adalah “Kriptografi berbasis kisi (Lattice-based cryptography)”. Dibandingkan dengan metode lain, kriptografi berbasis kisi memiliki fitur luar biasa bahwa kecepatan pemrosesan enkripsi dan dekripsi sangat cepat, dan juga memiliki bukti keamanan yang sangat kuat dalam teori kriptografi, yaitu reduksi dari “kompleksitas kasus terburuk (Worst-case complexity)” ke “kompleksitas kasus rata-rata (Average-case complexity)”.

Dalam artikel ini, kita akan memulai dari definisi matematis “Kisi (Lattice)” yang menjadi dasar kriptografi berbasis kisi ini, dan membahas secara mendalam tentang masalah-masalah sulit di atas kisi seperti SVP (Masalah Vektor Terpendek) dan CVP (Masalah Vektor Terdekat), serta “Masalah LWE (Learning With Errors)” yang dapat dikatakan sebagai jantung dari kriptografi berbasis kisi modern, disertai dengan rumus, intuisi geometris, dan contoh numerik konkret.

2. Definisi Matematis dan Intuisi Geometris dari Kisi (Lattice)

2.1 Ruang Vektor dan Kisi

Dalam matematika, “Kisi (Lattice)” adalah himpunan titik-titik diskrit yang tersusun secara teratur dalam ruang vektor real berdimensi-$n$ $\mathbb{R}^n$. Ini mirip dengan Ruang Vektor (Vector Space) yang dipelajari dalam aljabar linear, tetapi ada perbedaan krusial. Sementara ruang vektor adalah ruang kontinu yang direpresentasikan oleh kombinasi linear dari vektor-vektor basis dengan “koefisien bilangan real”, kisi adalah ruang diskrit yang direpresentasikan oleh kombinasi linear dari vektor-vektor basis dengan “koefisien bilangan bulat”.

Mari kita berikan definisi matematis yang ketat. Pertimbangkan $n$ buah ($n \le m$) vektor linear independen $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ dalam ruang vektor real berdimensi-$m$ $\mathbb{R}^m$. Misalkan matriks yang memiliki vektor-vektor ini sebagai vektor kolom adalah $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$. Kita menyebut $B$ ini sebagai “Basis” dari kisi.

Kisi $\mathcal{L}(B)$ yang dihasilkan oleh basis $B$ ini didefinisikan sebagai berikut:

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

Yang penting di sini adalah bahwa koefisien $x_i$ tidak dibatasi pada bilangan real $\mathbb{R}$, melainkan pada bilangan bulat $\mathbb{Z}$. Dengan ini, alih-alih titik kontinu tak terhingga yang ada di dalam ruang, terbentuklah “himpunan titik-titik diskrit” yang menyerupai persimpangan jaring yang disusun pada interval yang sama.

2.2 Citra Geometris

Mari kita pertimbangkan contoh bidang 2 dimensi $\mathbb{R}^2$. Jika kita memilih $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ dan $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ sebagai vektor basis, kisi yang dihasilkan oleh keduanya akan menjadi himpunan semua koordinat bilangan bulat $(x, y) \in \mathbb{Z}^2$ pada bidang koordinat. Ini adalah “kisi persegi” yang paling sederhana.

Namun, kisi tidak selalu ortogonal. Misalnya, jika kita mempertimbangkan basis $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ dan $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, titik-titik yang dihasilkan akan terlihat seperti persimpangan jaring yang miring.

2.3 Ketidakunikan Basis dan Transformasi Unimodular

Terdapat sifat penting yang berkaitan dengan akar keamanan kriptografi berbasis kisi. Yaitu, “ada jumlah tak terhingga basis yang menghasilkan kisi yang sama”.

Sebagai contoh, kisi $\mathbb{Z}^2$ yang dihasilkan oleh basis $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ sebelumnya akan menghasilkan kisi $\mathbb{Z}^2$ yang sama persis bahkan jika kita menggunakan basis $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$.

Syarat perlu dan cukup agar suatu basis $B$ dan basis lain $B'$ menghasilkan kisi yang sama adalah adanya suatu matriks elemen bilangan bulat $U \in \mathbb{Z}^{n \times n}$, dengan determinan $\det(U) = \pm 1$, sehingga dapat direpresentasikan sebagai

$$ B' = B U $$

Matriks $U$ semacam itu disebut “Matriks unimodular (Unimodular matrix)”.

Ide dasar dalam penerapannya pada kriptografi adalah menggunakan “basis yang baik (basis yang mendekati ortogonal dan terdiri dari vektor-vektor pendek)” sebagai kunci privat, dan menggunakan “basis yang buruk (basis yang sangat miring satu sama lain dan terdiri dari vektor-vektor yang sangat panjang)” sebagai kunci publik. Mencari basis yang baik dari basis yang buruk melalui perhitungan menjadi sangat sulit ketika dimensinya tinggi. Inilah intuisi dasar dari kriptografi berbasis kisi.

3. Masalah Komputasi yang Sulit pada Kisi

Keamanan kriptografi berbasis kisi bergantung pada kesulitan memecahkan masalah matematis tertentu pada kisi. Di sini, kita akan memperkenalkan dua masalah yang paling mendasar dan terkenal.

3.1 Masalah Vektor Terpendek (Shortest Vector Problem: SVP)

SVP adalah masalah yang paling klasik dan terkenal dalam teori kisi.

Definisi (SVP): Diberikan sembarang basis kisi $B$, temukan vektor $\mathbf{v}$ dengan norma Euclidean (panjang) terkecil di antara vektor-vektor bukan nol yang termasuk dalam kisi $\mathcal{L}(B)$ tersebut.

Dinyatakan dalam rumus, ini adalah masalah mencari $\mathbf{v}$ sehingga $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. Panjang minimum ini ditulis sebagai $\lambda_1(\mathcal{L})$ dan disebut “Minimum berurutan pertama (First successive minimum) dari kisi”.

Dalam dimensi rendah seperti 2 atau 3 dimensi, jika Anda menggambar sebuah gambar, Anda dapat melihat dan menemukan vektor terpendek dengan mata. Atau, Anda dapat menyelesaikannya secara efisien menggunakan algoritma reduksi kisi Gauss. Namun, ketika dimensi $n$ menjadi dimensi tinggi seperti ratusan hingga ribuan, diketahui bahwa memecahkan SVP secara eksak adalah NP-hard.

Dalam kriptografi dunia nyata, alih-alih vektor terpendek eksak, SVP perkiraan ($\gamma$-SVP) yang menemukan “vektor yang secara perkiraan pendek” digunakan. Jika faktor perkiraan $\gamma$ berukuran polinomial, masalah ini masih dianggap sangat sulit.

3.2 Masalah Vektor Terdekat (Closest Vector Problem: CVP)

CVP juga merupakan masalah yang sangat penting dalam kriptografi berbasis kisi.

Definisi (CVP): Diberikan sembarang basis kisi $B$, dan sembarang vektor target $\mathbf{t} \in \mathbb{R}^m$ di dalam ruang (tidak harus titik kisi), temukan titik kisi $\mathbf{v} \in \mathcal{L}(B)$ di antara titik-titik kisi yang paling dekat dengan $\mathbf{t}$.

Dinyatakan dalam rumus, ini adalah masalah mencari titik kisi $\mathbf{v}$ sehingga $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

CVP juga bersifat NP-hard dalam dimensi tinggi, sama seperti SVP. Dari perspektif aplikasi untuk kriptografi, masalah LWE yang dijelaskan di bawah ini berkaitan erat dengan varian khusus dari CVP (Bounded Distance Decoding: BDD).

3.3 Mengapa Menjadi Tidak Dapat Dipecahkan Saat Dimensi Tinggi? (Keterbatasan LLL dan BKZ)

Sebagai algoritma terkenal untuk memecahkan masalah kisi berdimensi tinggi, terdapat algoritma LLL (Lenstra-Lenstra-Lovász algorithm). Algoritma LLL beroperasi dalam waktu polinomial dan dapat mereduksi (Reduction) basis kisi menjadi “basis yang baik” sampai tingkat tertentu. Namun, vektor terpendek yang dapat ditemukan oleh algoritma LLL memiliki faktor perkiraan yang eksponensial ($2^{\mathcal{O}(n)}$) terhadap panjang vektor terpendek yang sebenarnya, sehingga tidak mencapai tingkat di mana ia dapat merusak keamanan kriptografi.

Jika kita menggunakan algoritma reduksi basis yang lebih kuat seperti algoritma BKZ (Block Korkine-Zolotarev) yang merupakan peningkatan dari LLL, kita dapat menemukan vektor yang lebih pendek, tetapi kompleksitas komputasinya meningkat secara eksponensial sehubungan dengan ukuran blok. Dalam kriptografi berbasis kisi, parameter yang aman (seperti ukuran dimensi $n$) ditentukan dengan memperkirakan waktu eksekusi dari algoritma BKZ ini. Dalam parameter standar PQC saat ini, nilai 500 hingga 1000 atau lebih dipilih untuk dimensi $n$, dan dikatakan bahwa akan memakan waktu lebih lama daripada umur alam semesta untuk mendekripsinya, bahkan dengan superkomputer atau komputer kuantum di masa depan.

4. Formulasi Matematis dari Masalah LWE (Learning With Errors)

Sebagian besar kriptografi berbasis kisi modern didasarkan pada “Masalah LWE (Learning With Errors)” yang diusulkan oleh Oded Regev pada tahun 2005. Keindahan dari masalah LWE terletak pada kesederhanaan formulasinya, dan fakta bahwa ia memiliki bukti matematis yang kuat, yaitu “reduksi dari kompleksitas kasus terburuk ke kompleksitas kasus rata-rata”.

4.1 Sistem Persamaan Linear Tanpa Noise

Untuk memahami masalah LWE, pertama-tama mari kita pertimbangkan sistem persamaan linear sederhana tanpa noise. Misalkan ada vektor rahasia yang tidak diketahui $\mathbf{s} \in \mathbb{Z}_q^n$ (setiap komponen adalah bilangan bulat dari $0$ hingga $q-1$). Di sini $q$ adalah bilangan prima.

Kita memilih vektor koefisien acak $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$, dan menghitung hasil kali titik dengan vektor rahasia $\mathbf{s}$ dalam modulo $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Mengingat jumlah pasangan $(\mathbf{a}_i, b_i)$ yang cukup ($n$ atau lebih), kita dapat dengan mudah memulihkan vektor rahasia $\mathbf{s}$ dengan menggunakan “Eliminasi Gauss (Gaussian elimination)” dalam aljabar linear. Ini adalah masalah yang dapat dengan mudah diselesaikan dalam waktu polinomial.

4.2 Definisi Masalah LWE: Menambahkan Noise

Lalu, apa yang terjadi jika kita menambahkan sedikit “noise (kesalahan)” pada masalah ini? Inilah esensi dari masalah LWE.

Untuk vektor rahasia yang tidak diketahui $\mathbf{s} \in \mathbb{Z}_q^n$, kita menambahkan kesalahan kecil $e_i \in \mathbb{Z}_q$ ke hasil setiap persamaan. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Di sini, $e_i$ adalah nilai bilangan bulat kecil dengan rata-rata 0 dan standar deviasi yang relatif kecil (misalnya, dipilih dari distribusi Gaussian diskrit, seperti distribusi normal). Informasi yang diberikan adalah daftar pasangan vektor acak $\mathbf{a}_i$ dan $b_i$ yang dihitung dengan menambahkan kesalahan padanya. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

Jika kita merepresentasikan ini dengan matriks, ini menjadi sangat rapi. Menggunakan matriks acak $A \in \mathbb{Z}_q^{m \times n}$, vektor rahasia $\mathbf{s} \in \mathbb{Z}_q^n$, dan vektor kesalahan $\mathbf{e} \in \mathbb{Z}_q^m$,

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

dapat ditulis seperti di atas. Yang diberikan hanyalah $A$ dan $\mathbf{b}$. Mencari $\mathbf{s}$ dari sini adalah “Masalah pencarian LWE (Search LWE problem)”.

Karena terdapat kesalahan $e_i$, jika kita mencoba menggunakan eliminasi Gauss, kesalahan akan diperkuat secara eksponensial dalam proses penambahan dan pengurangan persamaan, sehingga mustahil untuk mencapai jawaban yang benar. Pada pandangan pertama, ini terlihat seperti sistem persamaan linear yang sederhana, tetapi hanya dengan menambahkan noise kecil ini, tingkat kesulitan masalah melompat ke tingkat NP-hard.

4.3 Masalah Keputusan LWE (Decision LWE)

Yang sering digunakan dalam pembuktian teori kriptografi adalah variasi dari masalah pencarian LWE, yaitu “Masalah keputusan LWE (Decision LWE problem)”.

Masalah keputusan LWE adalah masalah di mana, diberikan daftar sampel yang diperoleh dari salah satu dari dua distribusi berikut, kita harus menentukan dari distribusi mana sampel tersebut berasal.

Distribusi LWE: Secara sengaja dihitung $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
Distribusi acak seragam: Sepasang $(A, \mathbf{u})$ yang terdiri dari matriks $A$ dan vektor $\mathbf{u}$ yang dipilih secara acak sepenuhnya.

Hebatnya, jika parameter masalah LWE dipilih dengan tepat, pasangan data yang diperoleh dari distribusi LWE menjadi “secara komputasi tidak dapat dibedakan (Computationally Indistinguishable)” dari pasangan data yang sepenuhnya acak. Sifat inilah yang menjadi dasar bagi kriptografi berbasis LWE untuk dapat menghasilkan “teks sandi (ciphertext) yang tidak dapat dibedakan dari angka acak”.

4.4 Reduksi dari Kompleksitas Kasus Terburuk ke Kasus Rata-rata (Teorema Regev)

Pencapaian terbesar Oded Regev adalah menghubungkan kesulitan masalah LWE ini secara matematis dengan kesulitan masalah kisi yang disebutkan sebelumnya (SVP dan CVP).

Menggunakan reduksi kuantum (Quantum reduction), ia membuktikan bahwa “Jika ada algoritma waktu polinomial yang dapat menyelesaikan masalah LWE secara rata-rata (untuk $A$ dan $\mathbf{e}$ yang dipilih secara acak), maka ada algoritma kuantum waktu polinomial yang dapat menyelesaikan Gap-SVP kasus terburuk (kasus paling sulit) untuk sembarang kisi”. (Belakangan, reduksi klasik juga ditunjukkan oleh Peikert dkk.).

Ini adalah sifat yang diimpikan dalam teori kriptografi. Karena ini menghilangkan kekhawatiran bahwa “kriptografi mungkin dapat dipecahkan karena kita kebetulan memilih kunci yang lemah (bagian dari kasus rata-rata)”, dan memberikan jaminan kuat bahwa “jika LWE rata-rata dapat dipecahkan, semua masalah sulit dari kisi dapat dipecahkan (sehingga LWE mutlak sulit)”.

graph TD A["Masalah Kisi Kasus Terburuk (Gap-SVP, SIVP)"] -->|Reduksi Kuantum/Klasik| B["Masalah LWE Kasus Rata-rata"] B -->|Konstruksi Kriptografi| C["Kriptosistem berbasis LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Konstruksi Kriptografi Kunci Publik menggunakan LWE (Kriptografi Regev)

Setelah memahami kesulitan masalah LWE, mari kita lihat skema kriptografi kunci publik dasar yang diusulkan oleh Oded Regev tentang bagaimana menggunakannya untuk enkripsi dan dekripsi. Di sini, kita akan menjelaskan mekanisme paling dasar untuk mengenkripsi pesan 1-bit $M \in \{0, 1\}$.

5.1 Pembuatan Kunci (Key Generation)

Sebagai parameter sistem, kita tentukan bilangan prima $q$ yang menjadi modulo, dimensi $n$, dan jumlah persamaan $m$ ($m > n \log q$).
Sebagai kunci privat, pilih secara acak vektor $\mathbf{s} \in \mathbb{Z}_q^n$.
Hasilkan matriks acak $A \in \mathbb{Z}_q^{m \times n}$.
Pilih vektor kesalahan kecil $\mathbf{e} \in \mathbb{Z}_q^m$ dari distribusi kesalahan seperti distribusi Gaussian diskrit.
Hitung vektor $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
Kunci publik (Public Key) adalah $(A, \mathbf{b})$.
Kunci privat (Secret Key) adalah $\mathbf{s}$.

Kunci publik persis merupakan “instansiasi dari masalah LWE” itu sendiri. Menemukan kunci privat $\mathbf{s}$ dari kunci publik $(A, \mathbf{b})$ sama dengan memecahkan masalah pencarian LWE, sehingga keamanannya terjamin.

5.2 Enkripsi (Encryption)

Alice menggunakan kunci publik Bob $(A, \mathbf{b})$ untuk mengenkripsi pesan 1-bit $M \in \{0, 1\}$.

Pilih vektor biner acak (komponennya adalah 0 atau 1) $\mathbf{r} \in \{0, 1\}^m$.
Sebagai paruh pertama dari teks sandi, hitung vektor $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ adalah matriks transpose dari $A$. Dengan kata lain, ia menjumlahkan baris-baris dari $A$ di mana komponen dari $\mathbf{r}$ adalah 1).
Sebagai paruh kedua dari teks sandi, hitung skalar $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Jika pesan $M$ adalah 0, tidak ditambahkan apa-apa, dan jika $1$, ditambahkan persis setengah dari nilai $q$, yaitu $\lfloor \frac{q}{2} \rfloor$).
Teks sandi (Ciphertext) adalah $(\mathbf{u}, v)$.

Makna intuitif dari enkripsi adalah mengambil “jumlah subset acak” sehubungan dengan matriks kunci publik $A$ dan vektor $\mathbf{b}$. Karena kesulitan masalah keputusan LWE, teks sandi $(\mathbf{u}, v)$ ini tampak tidak dapat dibedakan dari vektor acak sepenuhnya dan bilangan acak seragam (Keamanan semantik: Semantic Security).

flowchart LR M["Pesan M dalam {0,1}"] --> Enc PK["Kunci Publik (A, b)"] --> Enc r["Vektor biner acak r"] --> Enc subgraph Enc ["Proses Enkripsi"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Teks Sandi (u, v)"]

5.3 Dekripsi (Decryption)

Bob mendekripsi teks sandi $(\mathbf{u}, v)$ menggunakan kunci privat $\mathbf{s}$.

Hitung nilai berikut: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Jika hasil perhitungan mendekati $0$, keluarkan $M=0$, jika mendekati $\lfloor \frac{q}{2} \rfloor$, keluarkan $M=1$.

Mari kita jabarkan secara matematis mengapa ini dapat didekripsi. Ingatlah bahwa $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

Di sini, dari rumus tersebut, $\mathbf{s}^T A^T \mathbf{r}$ saling meniadakan dengan rapi dan menghilang! Yang tersisa adalah $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ adalah vektor noise dengan komponen yang sangat kecil, dan $\mathbf{r}$ adalah vektor biner dengan komponen 0 atau 1. Oleh karena itu, hasil kali titik dari keduanya, $\mathbf{e}^T \mathbf{r}$, juga (jika parameter dipilih dengan benar) tetap merupakan nilai yang relatif kecil.

Jika $M=0$, hasilnya menjadi $\mathbf{e}^T \mathbf{r}$, yang merupakan nilai kecil mendekati $0$.
Jika $M=1$, hasilnya menjadi $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, yang terletak di sekitar nilai setengah dari $q$, yaitu $\lfloor \frac{q}{2} \rfloor$.

Jika parameter dirancang sedemikian rupa sehingga nilai absolut dari kesalahan $\mathbf{e}^T \mathbf{r}$ berada di bawah $\frac{q}{4}$, Bob dapat menentukan (mendekripsi) pesan $M$ secara akurat hanya dengan melihat apakah hasil perhitungan lebih dekat ke $0$ atau ke $\lfloor \frac{q}{2} \rfloor$. Ini adalah mekanisme indah di mana kriptografi berbasis LWE bekerja.

flowchart LR CT["Teks Sandi (u, v)"] --> Dec SK["Kunci Privat s"] --> Dec subgraph Dec ["Proses Dekripsi"] direction TB calc["Hitung D = v - s^T * u mod q"] check["Periksa apakah D lebih dekat ke 0 atau q/2"] end calc --> check Dec --> M_out["Pesan M yang Dipulihkan"]

6. Contoh Mainan (Toy Example) dari Kriptografi LWE dengan Nilai Numerik Spesifik

Saya pikir sulit untuk merasakan hanya dengan deretan rumus, jadi mari kita benar-benar mengatur parameter numerik yang sangat kecil dan mengikuti perhitungan dari enkripsi hingga dekripsi. (※ Dalam sistem kriptografi dunia nyata, untuk memastikan keamanan, nilai 500 atau lebih digunakan untuk $n$, dan ribuan atau lebih digunakan untuk $q$)

[Pengaturan Parameter]

Modulo $q = 17$ (Bilangan prima. Oleh karena itu, nilainya berkisar dari $0$ hingga $16$)
Dimensi $n = 2$
Jumlah persamaan $m = 4$
Misalkan kita mengenkripsi pesan $M = 1$.
Jumlah pergeseran pesan: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

[1. Fase Pembuatan Kunci] Bob memilih kunci privat $\mathbf{s}$, matriks $A$, dan vektor kesalahan $\mathbf{e}$ secara acak.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

Selanjutnya kita hitung kunci publik $\mathbf{b}$.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

Kita hitung ini dalam modulo 17. ($66 = 17 \times 3 + 15$, dst.)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

Tambahkan vektor kesalahan $\mathbf{e}$.

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

Kunci publiknya adalah $A$ dan $\mathbf{b} = (16, 0, 11, 1)^T$.

[2. Fase Enkripsi] Alice mengenkripsi pesan $M = 1$. Pilih vektor acak $\mathbf{r}$. Di sini kita tetapkan $\mathbf{r} = (1, 0, 1, 0)^T$.

Hitung $\mathbf{u}$.

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

Hitung $v$.

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

Tambahkan nilai $\lfloor 17/2 \rfloor = 8$ yang sesuai dengan pesan $M=1$.

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

Alice mengirimkan teks sandi $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ kepada Bob.

[3. Fase Dekripsi] Menerima teks sandi, Bob mendekripsinya menggunakan kunci privat $\mathbf{s} = (3, 4)^T$. Rumus proses dekripsi: Hitung $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

Di sini, di dunia modulo 17, $-8$ sama dengan $9$ ($-8 + 17 = 9$). Tentukan apakah nilai $D = 9$ yang diperoleh lebih dekat ke $0$ atau $8$ ($\lfloor 17/2 \rfloor$). Karena $9$ jelas lebih dekat ke $8$ daripada ke $0$, Bob berhasil memulihkan $M = 1$ dengan benar!

Mengapa menjadi $9$? Mari kita ingat kembali pembuktian sebelumnya. Bagian kesalahan adalah $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Oleh karena itu, hasil perhitungannya adalah $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, dan dapat dipastikan bahwa nilai sesuai dengan teori telah dihitung.

7. Evolusi Menuju Penerapan Praktis: Ring-LWE dan Module-LWE

Masalah LWE standar (Standard LWE) yang dijelaskan sejauh ini memiliki bukti keamanan yang sangat kuat, tetapi memiliki kelemahan fatal dalam penggunaan praktis. Yaitu “ukuran kunci menjadi raksasa” dan “biaya komputasi tinggi”.

Dalam Standard LWE, kunci publik berisi matriks raksasa $A \in \mathbb{Z}_q^{m \times n}$. Ketika parameter $n$ menjadi ratusan hingga ribuan, ukuran matriks ini mencapai beberapa megabyte, sehingga terlalu berat untuk dikirim dan diterima setiap saat dalam protokol komunikasi di internet (seperti TLS). Selain itu, perkalian matriks dan vektor membutuhkan kompleksitas komputasi sebesar $\mathcal{O}(n^2)$.

Untuk mengatasi masalah ini, diperkenalkanlah “Ring-LWE (RLWE)” dan “Module-LWE (MLWE)”, yang memasukkan struktur aljabar yang disebut cincin polinomial (Polynomial rings) ke dalam kisi.

7.1 Intuisi dari Ring-LWE

Dalam Ring-LWE, vektor dan matriks digantikan dengan elemen (polinomial) pada cincin polinomial $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Di sini $n$ dipilih sebagai pangkat 2).

Sementara kunci publik dari Standard LWE adalah matriks $A$, Ring-LWE menggunakan polinomial tunggal $a(x)$. Kunci privat $s(x)$ dan kesalahan $e(x)$ juga menjadi polinomial. Persamaannya menjadi sebagai berikut:

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

Karena ini adalah perkalian polinomial, dengan menggunakan “Number Theoretic Transform (NTT)”, yang mirip dengan Fast Fourier Transform (FFT), kompleksitas komputasi dapat dikurangi secara dramatis menjadi $\mathcal{O}(n \log n)$. Lebih jauh lagi, karena ukuran kunci publik juga berkurang dari matriks menjadi polinomial tunggal, ukuran data berkurang menjadi $\mathcal{O}(n)$. Ini memberikan keuntungan yang luar biasa dalam bandwidth komunikasi.

Secara matematis, Ring-LWE bukan direduksi menjadi masalah pada kisi umum, melainkan pada kisi dengan simetri khusus yang disebut “Kisi Ideal (Ideal Lattice)”.

7.2 Module-LWE dan Standardisasi NIST (Kyber / ML-KEM)

Meskipun Ring-LWE efisien, ada sedikit kekhawatiran bahwa struktur aljabar khusus dari kisi ideal dapat menjadi petunjuk untuk serangan di masa depan. Oleh karena itu, “Module-LWE (MLWE)” mengambil “yang terbaik dari kedua dunia” dari keamanan konservatif Standard LWE dan efisiensi Ring-LWE.

Dalam Module-LWE, kita mempertimbangkan matriks kecil dan vektor yang elemennya adalah polinomial. Dengan kata lain, kita menangani modul di atas cincin. Saat ini, “CRYSTALS-Kyber” (nama standar: ML-KEM), yang dipilih oleh NIST sebagai standar untuk algoritma enkapsulasi kunci (KEM) PQC, dibangun tepat di atas kesulitan masalah Module-LWE ini.

8. Mengapa Ini Aman Terhadap Komputer Kuantum?

Terakhir, mari kita sentuh bagian inti dari “Mengapa kriptografi berbasis kisi diyakini tidak dapat dipecahkan bahkan menggunakan komputer kuantum?”.

Algoritma Shor, yang digunakan komputer kuantum untuk memecahkan kriptografi RSA dan kriptografi kurva eliptik, pada dasarnya adalah algoritma untuk memecahkan “Masalah Subgrup Tersembunyi (Hidden Subgroup Problem: HSP)”. Struktur matematika di balik RSA dan ECC (grup Abelian hingga) memiliki periodisitas, dan dengan menggunakan operasi yang unik untuk algoritma kuantum yang disebut Transformasi Fourier Kuantum (Quantum Fourier Transform: QFT), periode ini (subgrup tersembunyi) dapat diekstraksi sekaligus.

Namun, masalah kisi pada dasarnya berbeda. Meskipun kisi juga memiliki periodisitas, apa yang dicari dalam SVP dan CVP adalah sifat geometris non-linear seperti “jarak terpendek” dan “penghilangan noise”. Bahkan jika “transformasi Fourier kuantum pada grup Abelian” seperti algoritma Shor diterapkan secara langsung, informasi berguna yang merupakan jawaban dari masalah kisi tidak dapat diekstraksi secara efisien. Hingga saat ini, tidak ada algoritma kuantum yang dapat memecahkan SVP dan LWE dalam waktu polinomial yang telah ditemukan, dan diyakini secara luas bahwa bahkan dengan kekuatan komputasi paralel dari komputer kuantum, satu-satunya metode yang efektif hanyalah pencarian yang mendekati brute force (percepatan akar kuadrat oleh algoritma Grover).

9. Kesimpulan

Dalam artikel ini, kami telah menjelaskan secara rinci tentang intuisi matematis kriptografi berbasis kisi, mulai dari definisi geometris kisi, formulasi masalah LWE, dan menuju konstruksi kriptografi kunci publik.

Kisi (Lattice) adalah ruang diskrit yang direpresentasikan oleh kombinasi linear koefisien bilangan bulat dari vektor basis, dan dalam dimensi tinggi menjadi sulit untuk menemukan “basis yang baik” yang mendekati ortogonal (SVP).
Masalah LWE (Learning With Errors) adalah masalah memecahkan sistem persamaan linear dengan noise, dan karena ini terkait dengan kesulitan masalah kasus terburuk pada kisi, ini memberikan bukti keamanan yang kuat.
Dengan menggunakan masalah LWE, enkripsi dan dekripsi (Kriptografi Regev) direalisasikan oleh mekanisme cerdik yang secara sengaja menambahkan atau menghapus noise.
Dalam protokol dunia nyata, untuk meningkatkan efisiensi komunikasi dan kecepatan komputasi, Ring-LWE dan Module-LWE yang menggunakan cincin polinomial diadopsi, dan ini menjadi fondasi ML-KEM yang merupakan standar NIST.

Di tengah pergeseran paradigma komputasi yang belum pernah terjadi sebelumnya yang disebut komputer kuantum, sangatlah romantis bahwa “Kriptografi berbasis kisi”, yang lahir dari kedalaman aljabar linear klasik dan teori bilangan, akan memikul fondasi keamanan internet masa depan. Matematika yang menjadi dasar kriptografi berbasis kisi sama sekali tidak terlalu sulit untuk dipahami, dan dengan pengetahuan dasar tentang aljabar linear dan probabilitas, struktur indahnya dapat dipahami dengan baik. Kami berharap artikel ini dapat membantu Anda dalam memahami kriptografi berbasis kisi, yang merupakan inti dari PQC.

Hipotesis Riemann dan Distribusi Bilangan Prima: Hubungan Mendalam dengan Kriptografi Modern

Fri, 11 Sep 2026 16:00:00 +0900

1. Pendahuluan: Misteri Alam Semesta Bilangan Prima dan Hipotesis Riemann

“Bilangan prima (Prime Numbers)” adalah bilangan asli yang hanya bisa dibagi oleh 1 dan bilangan itu sendiri, yang juga sering disebut sebagai “atom” dalam dunia matematika. Deret bilangan 2, 3, 5, 7, 11, 13… ini pada pandangan pertama terlihat tidak beraturan dan muncul secara acak. Sejak matematikawan Yunani kuno, Euclid, membuktikan bahwa “bilangan prima jumlahnya tak terhingga”, tak terhitung banyaknya matematikawan yang menantang diri mereka untuk mengungkap keteraturan yang tersembunyi di balik susunan bilangan prima ini.

Yang paling mendekati misteri bilangan prima ini adalah “Hipotesis Riemann (Riemann Hypothesis)”, yang diusulkan oleh matematikawan Jerman, Bernhard Riemann, pada tahun 1859. Hipotesis Riemann adalah salah satu dari masalah terpenting dan belum terpecahkan dalam matematika modern, serta merupakan salah satu dari Masalah Hadiah Milenium (Millennium Prize Problems) yang ditetapkan oleh Clay Mathematics Institute dengan hadiah sebesar 1 juta dolar.

Sekilas, masalah sulit matematika murni terkait distribusi bilangan prima mungkin terasa tidak ada hubungannya dengan kehidupan kita sehari-hari. Namun, keamanan internet yang menopang infrastruktur masyarakat modern, terutama teknologi kriptografi modern seperti kriptografi RSA dan kriptografi kurva eliptik (ECC), sangat bergantung pada sifat-sifat bilangan prima yang sangat besar.

Dalam artikel ini, kita akan melakukan perjalanan matematis dari distribusi bilangan prima menuju Teorema Bilangan Prima, fungsi Zeta Riemann, hingga ke inti dari Hipotesis Riemann, lalu menggali lebih dalam dan detail tentang bagaimana hal tersebut terhubung dengan teknologi kriptografi modern, serta apa yang akan terjadi pada dunia jika Hipotesis Riemann berhasil dibuktikan.

2. Teorema Bilangan Prima dan Distribusi Bilangan Prima: Penemuan Gauss

Untuk memahami bagaimana bilangan prima terdistribusi, para matematikawan memikirkan fungsi penghitungan bilangan prima (Prime-counting function) $\pi(x)$, yang menyatakan “berapa banyak bilangan prima yang ada di bawah suatu bilangan $x$”.

Sebagai contoh:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

Carl Friedrich Gauss, seorang matematikawan jenius berusia 15 tahun, menghitung tabel bilangan prima yang sangat besar dan menemukan bahwa frekuensi kemunculan bilangan prima berkurang secara berbanding terbalik dengan logaritma natural $\ln x$. Dengan kata lain, ia memperkirakan bahwa peluang menemukan bilangan prima di sekitar suatu bilangan $x$ adalah sekitar $\frac{1}{\ln x}$.

Representasi dari penemuan ini menggunakan integral disebut integral logaritmik (Logarithmic integral) $\text{Li}(x)$.

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

Perkiraan Gauss kemudian dibuktikan secara independen oleh Jacques Hadamard dan Charles-Jean de La Vallée Poussin pada tahun 1896, yang memantapkannya sebagai Teorema Bilangan Prima (Prime Number Theorem, PNT).

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

Atau secara pendekatan dinyatakan sebagai berikut.

$$ \pi(x) \sim \frac{x}{\ln x} $$

Melalui teorema ini, kita mengetahui bahwa jika dilihat secara makroskopis, bilangan prima memiliki distribusi yang sangat mulus dan dapat diprediksi. Namun, jika dilihat secara mikroskopis, selalu terdapat “galat (error)” atau “fluktuasi” antara $\pi(x)$ dan $\text{Li}(x)$. Sifat asli dari fluktuasi inilah misteri terbesar yang coba dipecahkan oleh Hipotesis Riemann.

3. Fungsi Zeta Riemann dan Produk Euler

Senjata paling kuat dalam menganalisis distribusi bilangan prima adalah Fungsi Zeta Riemann (Riemann Zeta Function). Awalnya, fungsi ini adalah deret tak terhingga yang didefinisikan untuk bilangan real $s > 1$ oleh Leonhard Euler.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

Salah satu pencapaian terbesar Euler adalah membuktikan bahwa deret tak terhingga ini dapat dinyatakan sebagai produk tak terhingga (perkalian tak terhingga) atas semua bilangan prima $p$. Inilah yang disebut dengan Produk Euler (Euler Product Formula).

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

Pemahaman intuitif dari pembuktian ini adalah dengan mengekspansi setiap suku di ruas kanan sebagai deret geometri, lalu mengalikannya. Berdasarkan Teorema Dasar Aritmetika (setiap bilangan asli dapat direpresentasikan secara unik sebagai hasil kali bilangan prima), jumlah kebalikan dari bilangan asli pada ruas kiri akan direkonstruksi sepenuhnya.

Satu rumus matematika ini menjadi jembatan yang menghubungkan analisis (deret tak terhingga, fungsi kontinu) dengan teori bilangan (bilangan prima, angka diskrit). Menyelidiki fungsi zeta sama artinya dengan menyelidiki distribusi bilangan prima.

4. Perluasan Analitik dan Perluasan ke Bidang Kompleks

Kejeniusan Riemann terletak pada kenyataan bahwa ia memperluas variabel $s$ dalam $\zeta(s)$, yang awalnya hanya dipertimbangkan Euler pada bilangan real, menjadi bilangan kompleks $s = \sigma + it$ ($\sigma$ adalah bagian real, $t$ adalah bagian imajiner).

Deret tak terhingga aslinya hanya konvergen pada $\sigma > 1$, namun Riemann menggunakan metode yang disebut “Perluasan Analitik (Analytic Continuation)” untuk memperluas definisi sehingga $\zeta(s)$ memiliki arti di seluruh bidang kompleks, kecuali pada titik kutub $s = 1$.

Lebih lanjut, ia menurunkan persamaan fungsional (Functional equation) indah yang dipenuhi oleh fungsi zeta.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

Di sini, $\Gamma(x)$ adalah fungsi Gamma. Berdasarkan persamaan ini, kita dapat mengetahui sifat di bidang sebelah kiri dari sifat di bidang sebelah kanan.

Pembuat Nol (Zeros of the Zeta Function)

Bilangan kompleks $s$ yang membuat nilai fungsi zeta menjadi 0 disebut sebagai “pembuat nol” (titik nol). Dari persamaan fungsional, ketika $s$ adalah bilangan genap negatif ($-2, -4, -6, \dots$), nilai $\sin(\pi s / 2)$ menjadi 0, sehingga $\zeta(s) = 0$. Ini disebut sebagai pembuat nol trivial (Trivial zeros).

Namun, yang penting dalam distribusi bilangan prima adalah pembuat nol lainnya, yaitu pembuat nol non-trivial (Non-trivial zeros) yang berada di dalam “jalur kritis (Critical strip)” $0 \le \sigma \le 1$.

5. Inti dari Hipotesis Riemann dan Rumus Eksplisit

Riemann menghitung sejumlah kecil pembuat nol dan merumuskan sebuah dugaan yang mengejutkan. Inilah Hipotesis Riemann.

Hipotesis Riemann (Riemann Hypothesis) Semua pembuat nol non-trivial dari fungsi zeta Riemann $\zeta(s)$ berada pada garis dengan bagian real $1/2$ ($\text{Re}(s) = 1/2$).

Garis dengan bagian real 1/2 ini disebut sebagai “Garis kritis (Critical line)”.

graph TD A["Fungsi Zeta Riemann ζ(s)"] --> B["Perluasan ke bidang kompleks dengan perluasan analitik"] B --> C["Pembuat nol trivial (s = -2, -4, -6 ...)"] B --> D["Pembuat nol non-trivial (0 <= Re(s) <= 1)"] D --> E["Hipotesis Riemann"] E --> F["Semua pembuat nol non-trivial berada pada Re(s) = 1/2"] F --> G["Menuju pembuktian limit suku galat dari distribusi bilangan prima"]

Mengapa Hipotesis Riemann begitu penting? Hal itu karena pembuat nol dari fungsi zeta sepenuhnya menentukan distribusi bilangan prima.

Riemann dan kemudian matematikawan von Mangoldt, menurunkan “Rumus eksplisit (Explicit formula)” yang mendeskripsikan distribusi bilangan prima dengan akurat. Dengan menggunakan fungsi Chebyshev $\psi(x)$, hal tersebut diekspresikan sebagai berikut.

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

Di sini, $\rho$ adalah penjumlahan atas semua pembuat nol non-trivial dari fungsi zeta. Suku utamanya adalah $x$ (yang berkorespondensi dengan Teorema Bilangan Prima), dan dengan menambahkan/mengurangkan suku berbentuk gelombang yang bergantung pada pembuat nol $\rho$, bentuk tangga distribusi bilangan prima yang akurat dapat dipulihkan. Dapat dikatakan bahwa pembuat nol non-trivial merepresentasikan “frekuensi (gelombang)” dari distribusi bilangan prima.

Jika Hipotesis Riemann benar, dan bagian real dari semua pembuat nol non-trivial $\rho$ tepat bernilai $1/2$, maka suku galat pada Teorema Bilangan Prima secara teoretis akan berada pada rentang batas minimum yang mungkin terbayangkan.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{untuk} \quad x \ge 2657 $$

Dengan kata lain, jika Hipotesis Riemann terbukti benar, hal itu akan membuktikan bahwa bilangan prima terdistribusi dengan cara yang paling “teratur dan indah” yang dapat kita bayangkan.

6. Hubungan yang Tak Terpisahkan Antara Teknologi Kriptografi Modern dan Bilangan Prima

Sejauh ini kita berada di ranah matematika murni yang mendalam, namun sifat bilangan prima ini menjadi pondasi dasar bagi masyarakat digital modern. Contoh utamanya adalah kriptografi kunci publik seperti Kriptografi RSA.

Keamanan dari berbagai komunikasi, mulai dari pembayaran kartu kredit di internet, pengiriman kata sandi, hingga tanda tangan digital pada blockchain, semuanya bergantung pada “bilangan prima”.

Cara Kerja Kriptografi RSA

Keamanan kriptografi RSA didasarkan pada fakta matematis (masalah faktorisasi prima) bahwa “memfaktorkan bilangan komposit (majemuk) dengan jumlah digit yang besar adalah hal yang sangat sulit”.

Pembuatan Kunci: Pilih secara acak bilangan prima $p$ dan $q$ yang berukuran besar (misalnya masing-masing 2048 bit). Kalikan keduanya untuk menghitung $N = p \times q$. Nilai $N$ ini menjadi bagian dari kunci publik. Gunakan fungsi totient Euler $\phi(N) = (p-1)(q-1)$ untuk menghasilkan kunci privat $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Enkripsi dan Dekripsi: Teks terang (plaintext) $M$ diubah menjadi teks sandi (ciphertext) $C$ menggunakan kunci publik $e$ dan $N$.
$$ C \equiv M^e \pmod{N} $$
Hanya orang yang memiliki kunci privat $d$ yang bisa melakukan dekripsi.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Teks Terang (Plaintext)"] --> B["Enkripsi dengan Kunci Publik (e, N)"] B --> C["Teks Sandi (Ciphertext)"] C --> D["Dekripsi dengan Kunci Privat (d)"] D --> E["Teks Terang Asli"] F["Penyerang (Attacker)"] -- "Mencoba faktorisasi prima dari N" --> C F -.-> G["Tanpa mengetahui p dan q, d tidak dapat dihitung"]

Untuk memecahkan kriptografi RSA, seseorang harus menemukan (melakukan faktorisasi prima) bilangan prima asli $p$ dan $q$ dari nilai $N$ yang sangat besar. Meskipun menggunakan algoritma arus utama saat ini (seperti General Number Field Sieve: GNFS), memfaktorkan angka dengan ratusan digit akan membutuhkan waktu jauh melampaui usia alam semesta, bahkan jika menggunakan superkomputer sekalipun.

7. Dampak Hipotesis Riemann terhadap Teknologi Kriptografi

Lalu, bagaimana “Hipotesis Riemann” yang berada di puncak matematika murni, bersinggungan dengan “teknologi kriptografi”?

7.1. Algoritma Pembangkitan Bilangan Prima (Pengujian Keprimaan) dan Hipotesis Riemann yang Diperluas (GRH)

Untuk mengoperasikan kriptografi RSA, pertama-tama kita perlu membangkitkan bilangan prima $p$ dan $q$ yang berukuran sangat besar. Akan tetapi, tidaklah mudah untuk memastikan dengan cepat dan pasti apakah “suatu bilangan merupakan bilangan prima atau bukan”.

Saat ini, metode yang digunakan secara praktis adalah algoritma probabilistik yang disebut Uji Keprimaan Miller-Rabin (Miller-Rabin primality test). Algoritma ini sangat cepat, namun memiliki risiko bahwa bilangan komposit disalahartikan sebagai bilangan prima atau disebut “bilangan prima semu (pseudoprime)” dengan probabilitas yang sangat kecil.

Namun, jika kita berasumsi bahwa “Hipotesis Riemann yang Diperluas (Generalized Riemann Hypothesis, GRH)”, yang memperluas Hipotesis Riemann pada fungsi L-Dirichlet bernilai benar, maka ceritanya akan berubah secara dramatis. Jika GRH benar, batas atas dari jumlah pengujian dalam uji Miller-Rabin akan dijamin secara matematis, sehingga meningkatkannya dari sekadar algoritma probabilistik menjadi “Algoritma Waktu Polinomial Deterministik” (Ini adalah fakta penting yang telah diketahui bahkan sebelum Uji Keprimaan AKS ditemukan).

Dengan kata lain, Hipotesis Riemann (dan perluasannya) memainkan peranan langsung dalam memberikan kepastian mutlak pada pondasi dasar kriptografi: “apakah kita dapat membangkitkan bilangan prima raksasa secara cepat dan dengan keyakinan yang pasti”.

7.2. Hubungan dengan Algoritma Faktorisasi Prima

Pengetahuan tentang distribusi bilangan prima juga mutlak diperlukan ketika mengevaluasi kompleksitas komputasi dari algoritma pihak pemecah sandi (seperti General Number Field Sieve). Banyak algoritma faktorisasi prima bergantung pada distribusi “bilangan mulus (Smooth numbers: bilangan yang hanya memiliki faktor prima kecil)”.

Untuk mengevaluasi secara ketat seberapa sering bilangan mulus ini muncul, pemahaman yang mendalam mengenai distribusi bilangan prima sangatlah diperlukan, dan di sinilah teknik teori bilangan analitik yang berhubungan langsung dengan fungsi zeta dan Hipotesis Riemann banyak digunakan. Jika Hipotesis Riemann berhasil dibuktikan, dan batas galat dari distribusi bilangan prima ditetapkan sepenuhnya, maka kita akan mampu mengidentifikasi batas performa algoritma faktorisasi prima secara lebih akurat.

8. Jika Hipotesis Riemann Terbukti, Apakah Kriptografi Akan Terpecahkan?

Terkadang muncul legenda urban yang mengatakan, “Jika Hipotesis Riemann terpecahkan, kriptografi RSA akan runtuh seketika”, tetapi secara matematis hal ini tidaklah tepat.

Pembuktian Hipotesis Riemann itu sendiri tidak serta merta akan langsung menghasilkan algoritma ajaib yang mempercepat faktorisasi prima secara drastis. Hipotesis Riemann pada dasarnya adalah teorema tentang “keteraturan distribusi bilangan prima secara makroskopis”, dan hal ini tidak serta merta memberikan petunjuk langsung tentang bilangan prima manakah yang dapat membagi bilangan $N$ tertentu (sifat secara lokal).

Namun, dampaknya tidaklah nol. Sebab, dalam proses pembuktian Hipotesis Riemann, probabilitas ditemukannya “peralatan matematis baru” atau “metode analisis yang belum pernah diketahui” sangatlah tinggi. Melihat sejarah ke belakang, ketika Teorema Terakhir Fermat atau Konjektur Poincaré dibuktikan, teori-teori baru yang dikembangkan selama proses tersebut telah mendorong lompatan besar bagi matematika secara keseluruhan.

Jika suatu metode geometri aljabar atau geometri non-komutatif yang belum diketahui dapat dimantapkan, di mana metode ini bisa mengontrol secara penuh sifat dari pembuat nol fungsi zeta Riemann, bukan tidak mungkin hal itu pada akhirnya berujung pada penemuan algoritma faktorisasi prima yang revolusioner (contohnya, algoritma klasik yang dapat mereduksi kompleksitas komputasi menjadi waktu polinomial). Dalam artian tersebut, para ahli kriptografi tidak pernah bisa memalingkan pandangannya dari perkembangan Hipotesis Riemann.

Komputer Kuantum dan Algoritma Shor

Ancaman yang lebih langsung dan nyata bagi teknologi kriptografi bukanlah pembuktian Hipotesis Riemann, melainkan komputer kuantum. “Algoritma Shor”, yang dipublikasikan oleh Peter Shor pada tahun 1994, membuktikan bahwa jika terdapat komputer kuantum dengan performa yang cukup, faktorisasi prima dapat dipecahkan dalam waktu polinomial. Hal ini secara mendasar akan mematahkan kriptografi RSA maupun kriptografi kurva eliptik.

Saat ini, transisi menuju “Kriptografi Pasca-Kuantum (Post-Quantum Cryptography, PQC)” (seperti kriptografi kisi/lattice-based cryptography), yang bahkan tidak dapat dipecahkan oleh komputer kuantum, sedang digalakkan di seluruh dunia. Teknologi kriptografi yang bergantung pada bilangan prima dalam beberapa artian mungkin sedang mendekati akhir masa keemasannya, namun nilai matematis dari bilangan prima itu sendiri tidak akan pernah pudar selamanya.

9. Penutup: Persimpangan Antara Abstraksi Matematika dan Dunia Nyata

graph TD A["Eksplorasi Matematika Murni"] --> B["Pengungkapan Hipotesis Riemann"] B --> C["Pemahaman Sempurna atas Distribusi Bilangan Prima"] C --> D["Perkembangan Pesat pada Teori Bilangan dan Geometri Aljabar"] D -.-> E["Kemungkinan Algoritma Faktorisasi Prima yang Baru"] E -.-> F["Pembaruan Evaluasi Keamanan Teknologi Kriptografi"] A --> G["Matematika Terapan dan Ilmu Komputer"] G --> H["Efisiensi Pengujian Keprimaan dan Pembangkitan Kriptografi"] H --> F

Pencarian tiada henti akan bilangan prima yang telah berlangsung sejak zaman Yunani Kuno, melalui tangan jenius bernama Riemann, disublimasikan menjadi sebuah simfoni yang indah di atas bidang kompleks (yaitu pembuat nol fungsi zeta). Dan yang sangat menakjubkan, kristalisasi dari matematika yang murni ini, melintasi waktu berabad-abad, kini diaplikasikan sebagai tameng terkuat yang menjamin keamanan masyarakat internet.

Hipotesis Riemann adalah sebuah eksistensi yang secara bersamaan menyimbolkan “keindahan yang abstrak” yang dimiliki matematika dan “daya aplikatifnya yang menakjubkan terhadap dunia fisik serta masyarakat nyata”.

Kelak suatu hari, ketika puncak gunung raksasa matematika yang belum pernah ditaklukkan oleh siapa pun ini berhasil didaki, kita tidak hanya akan memahami secara utuh kebenaran semesta dari bilangan prima, tetapi juga akan mendapatkan sudut pandang yang sama sekali baru mengenai landasan dari masyarakat informasi ini. Pada akhirnya, mempelajari teknologi kriptografi juga berarti menelusuri sejarah kebijaksanaan umat manusia itu sendiri.