Mathematics on kenji.blog

フェルマーの小定理を利用した暗号化の基礎と実装

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

1. はじめに：現代暗号を支える数学の神秘

現代のデジタル社会、とりわけインターネットを介した通信において、「暗号化」は不可欠な基盤技術となっています。私たちがウェブブラウザでHTTPS経由で安全にウェブサイトを閲覧し、オンラインバンキングで金融取引を行い、メッセージングアプリでプライベートなやり取りができるのは、高度な数学的理論に裏打ちされた暗号プロトコルが背後で機能しているからです。その中でも特に重要な役割を担っているのが「公開鍵暗号方式」であり、その代表格が RSA暗号 です。

RSA暗号をはじめとする多くの暗号アルゴリズムの安全性や正当性は、17世紀のフランスの数学者ピエール・ド・フェルマー（Pierre de Fermat）が発見した非常に美しく、かつ強力な定理に大きく依存しています。それが フェルマーの小定理（Fermat’s Little Theorem） です。さらに、これを一般化したレオンハルト・オイラー（Leonhard Euler）の定理も、暗号理論において決定的な役割を果たしています。

本記事では、フェルマーの小定理という純粋数学の発見が、いかにして現代の実用的な暗号技術、特に「素数判定」や「RSA暗号」へと応用されているのかを、基礎から徹底的に解説します。数学的な証明、暗号化・復号のメカニズム、そして C++ と Python を用いた具体的なアルゴリズムの実装までを網羅する、非常に詳細な技術ガイドとなります。

2. 合同式とモジュラ演算の基礎

フェルマーの小定理を理解するためには、まず「モジュラ演算（合同式）」という数学の概念に慣れ親しむ必要があります。モジュラ演算とは、ある決まった数（法、モジュラスと呼ばれる）で割った「余り」に着目した計算体系のことです。時計の文字盤（12時間で1周する）のような計算であるため、「時計の数学」とも呼ばれます。

整数 $a$ と $b$ を正の整数 $n$ で割った余りが等しいとき、数学的には以下のように記述します。

$$ a \equiv b \pmod n $$

これは「$n$ を法として $a$ と $b$ は合同である」と読みます。例えば、17 を 5 で割った余りは 2 であり、12 を 5 で割った余りも 2 です。したがって、次のように書くことができます。

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

モジュラ演算においては、通常の四則演算（足し算、引き算、掛け算）がそのまま成り立ちます。

加法: $a \equiv b \pmod n$ かつ $c \equiv d \pmod n$ ならば、$a + c \equiv b + d \pmod n$
減法: $a \equiv b \pmod n$ かつ $c \equiv d \pmod n$ ならば、$a - c \equiv b - d \pmod n$
乗法: $a \equiv b \pmod n$ かつ $c \equiv d \pmod n$ ならば、$a \times c \equiv b \times d \pmod n$
べき乗: $a \equiv b \pmod n$ ならば、任意の自然数 $k$ について $a^k \equiv b^k \pmod n$

ただし、除法（割り算） については注意が必要です。一般に、$a \times c \equiv b \times c \pmod n$ だからといって、両辺を $c$ で割って $a \equiv b \pmod n$ とすることはできません。これが成り立つのは、$c$ と $n$ が互いに素（最大公約数が 1）である場合に限られます。この「モジュラ逆元」の概念は、後述するRSA暗号の鍵生成において極めて重要になります。

3. フェルマーの小定理の数学的背景と証明

モジュラ演算の基礎を押さえたところで、本題であるフェルマーの小定理について見ていきましょう。

3.1 定理の定義

フェルマーの小定理は次のように定式化されます。

フェルマーの小定理 (Fermat’s Little Theorem) $p$ を素数とし、$a$ を $p$ の倍数ではない（すなわち $a$ と $p$ は互いに素である）任意の整数とする。このとき、次の合同式が成り立つ。
$$ a^{p-1} \equiv 1 \pmod p $$

また、条件「$a$ が $p$ の倍数でない」を外し、すべての整数 $a$ に対して成り立つ形として表現することも一般的です。その場合は両辺に $a$ を掛けて次のようになります。

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

3.2 具体例による確認

定理が本当に成り立つのか、具体的な数字を使って確認してみましょう。素数 $p = 5$ とします。$p-1 = 4$ です。$a$ として $p$ の倍数ではない整数を選びます。

$a = 2$ の場合: $2^{5-1} = 2^4 = 16$。$16 \div 5 = 3$ 余り $1$。よって $16 \equiv 1 \pmod 5$。（成立）
$a = 3$ の場合: $3^{5-1} = 3^4 = 81$。$81 \div 5 = 16$ 余り $1$。よって $81 \equiv 1 \pmod 5$。（成立）
$a = 4$ の場合: $4^{5-1} = 4^4 = 256$。$256 \div 5 = 51$ 余り $1$。よって $256 \equiv 1 \pmod 5$。（成立）

このように、どんな $a$ を選んでも（5の倍数でなければ）、4乗して5で割った余りは必ず1になります。魔法のように見えますが、これは素数が持つ美しい性質に由来しています。

3.3 定理の数学的証明

なぜこのようなことが成り立つのでしょうか。ここでは剰余類の集合を用いたエレガントな証明を紹介します。

集合 $S = \{1, 2, 3, \dots, p-1\}$ を考えます。これらは $p$ で割った余りが $1$ から $p-1$ になる整数の代表元です。ここで、各要素に $p$ と互いに素な整数 $a$ を掛けた新しい集合 $T$ を考えます。

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

この集合 $T$ の各要素を $p$ で割った余りを考えます。驚くべきことに、これらの余りは、順番こそ入れ替わるかもしれませんが、元の集合 $S$ の要素の集合と完全に一致します。なぜなら：

$T$ の要素が $p$ の倍数になることはありません（$a$ も元の要素も $p$ の倍数ではないため）。
$T$ の中で $p$ を法として合同になる2つの異なる要素は存在しません。もし $ia \equiv ja \pmod p$ （$i \neq j$）だとすると、$a$ と $p$ は互いに素なので $a$ で割ることができ、$i \equiv j \pmod p$ となって矛盾するからです。

したがって、$S$ の要素をすべて掛け合わせたものと、$T$ の要素をすべて掛け合わせたものは、$p$ を法として合同になります。

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

左辺を整理すると $a$ が $p-1$ 個あるので、

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

$(p-1)!$ は $p$ と互いに素なので、両辺を $(p-1)!$ で割ることができ、最終的に次の定理が導かれます。

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

これがフェルマーの小定理の証明です。

4. オイラーのトーティエント関数とオイラーの定理

フェルマーの小定理は「素数 $p$」に関する定理ですが、これを「任意の正の整数 $n$」に一般化したのが、レオンハルト・オイラーです。RSA暗号を理解するには、この拡張が不可欠です。

4.1 オイラーのトーティエント関数 $\phi(n)$

オイラーのトーティエント関数（あるいはオイラーの $\phi$ 関数） $\phi(n)$ は、「$1$ から $n$ までの整数のうち、$n$ と互いに素であるものの個数」を表す関数です。

素数 $p$ の場合、$1$ から $p-1$ までのすべての整数が $p$ と互いに素なので、$\phi(p) = p - 1$ となります。
2つの異なる素数 $p, q$ について、その積 $n = p \times q$ の場合、$\phi(n)$ は非常に簡単な式で求まります。 $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

この性質が、RSA暗号の鍵生成における根幹のロジックとなります。

4.2 オイラーの定理

オイラーは、フェルマーの小定理を次のように一般化しました。

オイラーの定理 (Euler’s Theorem) 正の整数 $n$ と、それと互いに素な整数 $a$ に対して、次が成り立つ。
$$ a^{\phi(n)} \equiv 1 \pmod n $$

もし $n$ が素数 $p$ であれば $\phi(p) = p - 1$ なので、これはフェルマーの小定理そのもの（$a^{p-1} \equiv 1 \pmod p$）になります。つまり、フェルマーの小定理はオイラーの定理の特殊なケースに過ぎません。

5. 巨大な素数を見つける：フェルマーの素数判定法

暗号技術（RSA暗号やDiffie-Hellman鍵交換など）においては、数百桁にも及ぶ「巨大な素数」を高速に見つけ出す必要があります。しかし、巨大な数 $N$ が素数かどうかを判定するために、$2$ から $\sqrt{N}$ までのすべての数で割り切れるか試す「試し割り法」では、宇宙の寿命ほどの時間がかかってしまいます。

そこで登場するのが、フェルマーの小定理を逆手に取った「確率的素数判定法」である フェルマーテスト（Fermat Primality Test） です。

5.1 確率的素数判定法とは

フェルマーの小定理によれば、$p$ が素数ならば、任意の $a$ ($1 < a < p$) に対して $a^{p-1} \equiv 1 \pmod p$ が必ず成立します。この対偶をとると、「ある $a$ について $a^{p-1} \not\equiv 1 \pmod p$ となった場合、$p$ は絶対に素数ではない（合成数である）」ということが言えます。

したがって、$N$ が素数かどうかを判定したい場合、ランダムにいくつか $a$ を選び、$a^{N-1} \pmod N$ を計算して $1$ になるかを確認します。もし1回でも $1$ 以外の答えが出れば、$N$ は合成数であると確定します。何度試しても $1$ になる場合、$N$ は「おそらく素数である」と高い確率で判断できます。

5.2 アルゴリズムの解説とフローチャート

フェルマーテストのアルゴリズムは以下の通りです。

flowchart TD Start["開始"] --> Input["判定対象の数 p と、テスト回数 k を入力"] Input --> LoopStart["i = 0 から k-1 までループ"] LoopStart --> Condition{"i < k ?"} Condition -- "Yes" --> RandomA["1 < a < p-1 の範囲でランダムな整数 a を選択"] RandomA --> Calc["モジュラべき乗 a^(p-1) mod p を計算"] Calc --> CheckPrime{"結果は 1 か？"} CheckPrime -- "No" --> ReturnComposite["p は合成数である（確定）"] CheckPrime -- "Yes" --> Increment["i をインクリメント"] Increment --> Condition Condition -- "No" --> ReturnPrime["p はおそらく素数である（確率的）"] ReturnComposite --> End["終了"] ReturnPrime --> End

5.3 カーマイケル数（偽素数）の落とし穴

フェルマーテストは非常に高速ですが、重大な欠点があります。それは、合成数であるにもかかわらず、すべての $a$ に対して $a^{N-1} \equiv 1 \pmod N$ を満たしてしまう悪魔のような数が存在することです。これを カーマイケル数 (Carmichael numbers) と呼びます。最も小さいカーマイケル数は $561$ ($3 \times 11 \times 17$) です。

カーマイケル数が存在するため、純粋なフェルマーテストだけでは絶対的な素数判定はできません。そのため、実際の暗号化システム（OpenSSLなど）では、フェルマーテストを改良した ミラー・ラビン（Miller-Rabin）素数判定法 が標準的に使用されています。ミラー・ラビン判定法はカーマイケル数を見破ることができるため、誤判定の確率を実質的にゼロにすることができます。

5.4 高速なべき乗剰余演算（繰り返し二乗法）

素数判定アルゴリズムの中で $a^{N-1} \pmod N$ を計算する必要がありますが、$N$ が巨大な場合、$a^{N-1}$ は天文学的な桁数になり、コンピュータのメモリに入りきりません。これを解決するのが 繰り返し二乗法（Exponentiation by Squaring） またはモジュラべき乗演算です。計算の各ステップで剰余（mod N）を取ることで、常に値が $N$ より小さく保たれ、非常に高速（$O(\log N)$の計算量）で計算可能になります。

6. 素数判定とべき乗剰余の実装

それでは、フェルマーの素数判定法と繰り返し二乗法を、C++とPythonで実装してみましょう。

6.1 C++ による実装

C++では標準の整数型がオーバーフローしやすいため、巨大な数を扱うには多倍長整数ライブラリ（GMPなど）が必要ですが、ここではアルゴリズムを理解するために64bit整数（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;

// 高速なべき乗剰余演算 (a^b mod m) - 繰り返し二乗法
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) {
 // bの最下位ビットが1の場合、結果にaを掛ける
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // オーバーフロー防止のため128bit拡張
 }
 // aを二乗する
 a = (__int128)a * a % m;
 // bを右シフト（半分にする）
 b /= 2;
 }
 return result;
}

// フェルマーの素数判定法
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);
 // a^(p-1) mod p が 1 でなければ合成数
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // おそらく素数
}

int main() {
 unsigned long long num = 1000000007; // 既知の素数
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Python による実装

Pythonの標準の整数型は多倍長整数をサポートしており、桁溢れを気にする必要がありません。さらにPythonの組み込み関数 pow(a, b, m) は内部的に繰り返し二乗法を使用しているため非常に高速です。

 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):
 """
 フェルマーの素数判定法を用いた確率的素数判定
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # 2 から p-2 の間でランダムな数 a を選ぶ
 a = random.randint(2, p - 2)
 # a^(p-1) mod p を計算。組み込みの pow は高速。
 if pow(a, p - 1, p) != 1:
 return False # 合成数確定

 return True # おそらく素数

# テスト
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} はおそらく素数です。")
else:
 print(f"{number_to_test} は合成数です。")

7. RSA暗号への応用：フェルマーとオイラーが結実する場所

フェルマーの小定理（およびオイラーの定理）の最も偉大な応用先が、1977年にRivest, Shamir, Adlemanの3人によって開発された RSA暗号 です。 RSA暗号は「公開鍵暗号」という画期的なシステムであり、暗号化するための鍵（公開鍵）は全世界に公開しておきながら、復号するための鍵（秘密鍵）は受信者本人だけが知っているという仕組みを実現しています。

この非対称性は、「巨大な合成数の素因数分解は極めて困難である」という計算量的安全性に基づいています。

7.1 RSA暗号の仕組み（鍵生成、暗号化、復号）

RSA暗号の全体的な通信フローをMermaidのシーケンス図で確認しましょう。

sequenceDiagram participant Alice["アリス (受信者)"] participant Bob["ボブ (送信者)"] Alice->>Alice: "巨大な素数 p, q を生成" Alice->>Alice: "N = p * q, φ(N) = (p-1)(q-1) を計算" Alice->>Alice: "公開鍵 e と秘密鍵 d を計算 (e*d ≡ 1 mod φ(N))" Alice->>Bob: "公開鍵 (N, e) を送信" Note over Bob: "平文 M を準備 (M < N)" Bob->>Bob: "暗号文 C = M^e mod N を計算" Bob->>Alice: "暗号文 C を送信" Alice->>Alice: "平文 M = C^d mod N を計算し復号"

以下に、数学的な詳細ステップを解説します。

ステップ1：鍵の生成（受信者アリスの作業）

2つの巨大な素数 $p$ と $q$ をランダムに生成します（ここで前述の素数判定法が使われます）。
その積 $N = p \times q$ を計算します。この $N$ は公開されます。
オイラーのトーティエント関数を用いて、$\phi(N) = (p-1)(q-1)$ を計算します。
$\phi(N)$ と互いに素な整数 $e$ （公開指数）を選びます（よく $e = 65537$ が使われます）。
$e$ のモジュラ逆元 $d$ （秘密指数）を計算します。すなわち、次を満たす $d$ を見つけます。 $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ この計算には 拡張ユークリッドの互除法 が用いられます。

これで、公開鍵は $(N, e)$、秘密鍵は $(N, d)$ となります。（$p, q, \phi(N)$ は直ちに破棄するか厳重に隠匿します）。

ステップ2：暗号化（送信者ボブの作業）

ボブはアリスにメッセージ $M$ を送りたいとします（$M$ は文字を数値化したもので、$0 \le M < N$ です）。ボブはアリスの公開鍵 $(N, e)$ を使い、次の計算を行って暗号文 $C$ を作ります。

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

この $C$ をネットワーク経由でアリスに送信します。

ステップ3：復号（受信者アリスの作業）

暗号文 $C$ を受け取ったアリスは、自分だけが知っている秘密鍵 $d$ を使って次の計算を行います。

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

驚くべきことに、この計算結果 $M'$ は元のメッセージ $M$ と完全に一致します。

7.2 なぜ復号できるのか？（数学的証明）

ここで、フェルマーの小定理（オイラーの定理）が真価を発揮します。なぜ $C^d \pmod N$ が $M$ に戻るのでしょうか？

復号の式を展開してみます。 $C \equiv M^e \pmod N$ ですから、

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

鍵生成のステップにおいて、$e \cdot d \equiv 1 \pmod{\phi(N)}$ となるように $d$ を選びました。これは、ある整数 $k$ が存在して、次のように書けることを意味します。

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

これを上の式に代入します。

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

ここで オイラーの定理 ($M^{\phi(N)} \equiv 1 \pmod N$) が登場します。（※厳密には $M$ と $N$ が互いに素である必要がありますが、RSAにおいては $M$ と $N$ が互いに素でない確率は天文学的に低く、かつ中国剰余定理を用いることで互いに素でなくても成立することが証明できます）。

オイラーの定理を適用すると、$M^{\phi(N)} \equiv 1$ なので、

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

見事に $M$ が復元されました！フェルマーとオイラーが何百年も前に発見した数の性質が、現代のデジタル通信の機密性を完璧に保証しているのです。

8. RSA暗号のトイ実装 (Python)

理論だけでは実感が湧きにくいため、Pythonを使って実際にRSA暗号の鍵生成・暗号化・復号のプロセスを実装してみましょう。これは教育用の「トイ（おもちゃ）実装」ですが、使われている数学は本物と全く同じです。

モジュラ逆元 $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

# 最大公約数を求める
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# 拡張ユークリッドの互除法 (ax + by = gcd(a,b) の x, y を求める)
# e*d ≡ 1 (mod φ(N)) の d を見つけるために使用
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('逆元が存在しません')
 else:
 return x % phi

# 素数生成関数（簡易版：小さな素数を生成）
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # 前述のフェルマーテストの代わりに簡易的に判定
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# RSA 鍵生成
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # p と q が同じにならないようにする
 while p == q:
 q = generate_prime(bits)

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

 # e は 65537 などの素数がよく使われるが、ここではランダムに選ぶ
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # 秘密鍵 d の計算
 d = mod_inverse(e, phi)

 # 公開鍵 (e, n), 秘密鍵 (d, n)
 return ((e, n), (d, n))

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

def decrypt(sk, ciphertext):
 d, n = sk
 # cipher^d mod n を計算し、文字に戻す
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# 実行例
if __name__ == '__main__':
 print("--- RSA暗号 トイ実装 ---")
 public_key, private_key = generate_keypair(bits=12) # 12bitの素数を使用

 print(f"公開鍵 (e, n): {public_key}")
 print(f"秘密鍵 (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\n元のメッセージ: {message}")

 # 暗号化
 encrypted_msg = encrypt(public_key, message)
 print(f"暗号文: {encrypted_msg}")

 # 復号
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"復号されたメッセージ: {decrypted_msg}")

このコードを実行すると、文字の配列が見慣れない数字の配列（暗号文）に変換され、それが秘密鍵によって見事に元の文字列に復元される様子が確認できます。

9. おわりに：数学の美しさと実用性の交差点

ピエール・ド・フェルマーがこの「小定理」を発見した17世紀当時、これが何かの役に立つと考えた人は皆無でした。フェルマー自身も純粋な数学的探求心から数論の研究を行っていました。

しかし、約300年後の1970年代、コンピュータネットワークの黎明期において、安全な通信プロトコルを確立するために不可欠な暗号技術として、フェルマーの定理は劇的な復活を遂げました。フェルマーの小定理に基づく素数判定技術と、オイラーの定理に基づくRSA暗号は、現代のインターネットインフラを文字通り支えています。

私たちが日々何気なく送っているLINEのメッセージも、Amazonでの買い物も、すべてはこの $a^{p-1} \equiv 1 \pmod p$ というシンプルで美しい数式の上で踊っているのです。数学がいかに抽象的であっても、いつか必ず人類の役に立つ時が来るということを、フェルマーの小定理は教えてくれています。

プログラミングや暗号理論を学ぶ上で、その基礎にある数学的構造を理解することは、ブラックボックスとして提供されているライブラリの挙動を深く理解し、よりセキュアなシステムを設計するための大きな武器になるでしょう。

格子暗号（Lattice-based cryptography）の数学的直観

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

1. 導入：ポスト量子暗号（PQC）の夜明けと格子暗号の台頭

現代社会のデジタルインフラを支えているのは、RSA暗号や楕円曲線暗号（ECC）をはじめとする公開鍵暗号技術です。これらの暗号方式は、「素因数分解問題」や「離散対数問題」といった、従来の古典コンピュータでは効率的に解くことができない（指数関数的な時間を要する）と信じられている数学的な困難性に安全性の根拠を置いています。

しかし、1994年にピーター・ショア（Peter Shor）によって発表された「Shorのアルゴリズム」は、暗号界に激震を走らせました。このアルゴリズムは、大規模な量子コンピュータが実現した暁には、素因数分解問題や離散対数問題を多項式時間で解いてしまうことを数学的に証明したのです。これはつまり、現在広く利用されている公開鍵暗号が、将来的に完全に解読可能になってしまうということを意味しています。

このような「量子コンピュータの脅威（Quantum Threat）」に対抗するため、量子コンピュータを用いても解読が困難な新しい暗号方式の研究が急務となりました。これが「ポスト量子暗号（Post-Quantum Cryptography: PQC）」または「耐量子計算機暗号」と呼ばれる分野です。

PQCにはいくつかの有力な候補が存在します。ハッシュベース暗号、符号ベース暗号、多変数多項式暗号、同種写像暗号などが挙げられますが、その中でも現在最も注目を集め、NIST（米国国立標準技術研究所）によるPQC標準化プロセスの中心となっているのが「格子暗号（Lattice-based cryptography）」です。格子暗号は、他の方式と比較して、暗号化・復号の処理速度が非常に高速であり、また「最悪時計算量（Worst-case complexity）」から「平均時計算量（Average-case complexity）」への帰着という、暗号理論において極めて強力な安全性の証明を持つという際立った特徴を持っています。

本記事では、この格子暗号の基礎となる「格子（Lattice）」の数学的定義から出発し、格子上の困難な問題であるSVP（最短ベクトル問題）やCVP（最近接ベクトル問題）、そして現代の格子暗号の心臓部とも言える「LWE問題（Learning With Errors）」について、数式と幾何学的な直観、そして具体的な数値例を交えて、徹底的に深く解説していきます。

2. 格子（Lattice）の数学的定義と幾何学的直観

2.1 ベクトル空間と格子

数学において、「格子（Lattice）」とは、$n$次元実ベクトル空間 $\mathbb{R}^n$ 内に規則正しく並んだ離散的な点の集合のことです。線形代数学で学ぶベクトル空間（Vector Space）と似ていますが、決定的な違いがあります。ベクトル空間が基底ベクトルの「実数係数」での線形結合で表される連続的な空間であるのに対し、格子は基底ベクトルの「整数係数」での線形結合で表される離散的な空間です。

数学的な厳密な定義を与えましょう。$m$次元実ベクトル空間 $\mathbb{R}^m$ における $n$ 本（$n \le m$）の線形独立なベクトル $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ を考えます。これらのベクトルを列ベクトルとして持つ行列を $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$ とします。この $B$ を格子の「基底（Basis）」と呼びます。

この基底 $B$ によって生成される格子 $\mathcal{L}(B)$ は、次のように定義されます。

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

ここで重要なのは、係数 $x_i$ が実数 $\mathbb{R}$ ではなく、整数 $\mathbb{Z}$ に限定されているという点です。これにより、空間内に無数に存在する連続的な点ではなく、等間隔に配置された交差点のような「離散的な点の集合」が形成されます。

2.2 幾何学的なイメージ

2次元平面 $\mathbb{R}^2$ の例で考えてみましょう。基底ベクトルとして $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ と $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ を選んだ場合、これらによって生成される格子は、座標平面上のすべての整数座標 $(x, y) \in \mathbb{Z}^2$ の集合となります。これは最も単純な「正方格子」です。

しかし、格子は常に直交しているわけではありません。例えば、$\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ と $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$ という基底を考えると、生成される点は斜めに歪んだ網目の交点のようになります。

2.3 基底の非一意性とユニモジュラ変換

格子暗号の安全性の根幹に関わる重要な性質があります。それは、「同一の格子を生成する基底は無数に存在する」ということです。

例えば、先ほどの $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ という基底が生成する $\mathbb{Z}^2$ 格子は、$\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$ という基底を使っても全く同じ格子 $\mathbb{Z}^2$ を生成します。

ある基底 $B$ と別の基底 $B'$ が同じ格子を生成するための必要十分条件は、ある整数成分の行列 $U \in \mathbb{Z}^{n \times n}$ であって、行列式が $\det(U) = \pm 1$ となるものが存在し、

$$ B' = B U $$

と表せることです。このような行列 $U$ を「ユニモジュラ行列（Unimodular matrix）」と呼びます。

暗号への応用における基本的なアイデアは、「良い基底（直交に近く、短いベクトルからなる基底）」を秘密鍵とし、「悪い基底（互いに極端に斜交し、非常に長いベクトルからなる基底）」を公開鍵として用いることです。悪い基底から良い基底を計算で求めることは、次元が高くなると非常に困難になります。これが格子暗号の基本的な直観です。

3. 格子における計算困難な問題

格子暗号の安全性は、格子上の特定の数学的問題を解くことの困難性に依存しています。ここでは、最も基本的かつ有名な2つの問題を紹介します。

3.1 最短ベクトル問題（Shortest Vector Problem: SVP）

SVPは、格子理論において最も古典的で有名な問題です。

定義（SVP）: 任意の格子基底 $B$ が与えられたとき、その格子 $\mathcal{L}(B)$ に属する非ゼロベクトルの中で、ユークリッドノルム（長さ）が最小となるベクトル $\mathbf{v}$ を見つけよ。

数式で表すと、$\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$ となる $\mathbf{v}$ を求める問題です。この最小の長さを $\lambda_1(\mathcal{L})$ と書き、「格子の第一連続最小値（First successive minimum）」と呼びます。

2次元や3次元の低い次元であれば、図を描けば目で見て一番短いベクトルを見つけることができます。あるいは、ガウスの格子簡約アルゴリズムなどを使って効率的に解くことができます。しかし、次元 $n$ が数百〜数千といった高次元になると、SVPを厳密に解くことはNP困難であることが知られています。

現実の暗号では、厳密な最短ベクトルではなく、「近似的に短いベクトル」を見つける近似SVP（$\gamma$-SVP）が用いられます。近似係数 $\gamma$ が多項式サイズの場合、この問題は依然として非常に難しいと考えられています。

3.2 最近接ベクトル問題（Closest Vector Problem: CVP）

CVPもまた、格子暗号において極めて重要な問題です。

定義（CVP）: 任意の格子基底 $B$ と、空間内の任意のターゲットベクトル $\mathbf{t} \in \mathbb{R}^m$ （必ずしも格子点ではない）が与えられたとき、格子点の中で $\mathbf{t}$ に最も近い格子点 $\mathbf{v} \in \mathcal{L}(B)$ を見つけよ。

数式で表すと、$\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$ となる格子点 $\mathbf{v}$ を探す問題です。

CVPもSVPと同様に、高次元においてはNP困難です。暗号への応用という観点では、後述するLWE問題は、このCVPの特殊な変種（Bounded Distance Decoding: BDD）と密接な関係があります。

3.3 なぜ高次元になると解けないのか？（LLLとBKZの限界）

高次元の格子問題を解くための有名なアルゴリズムとして、LLLアルゴリズム（Lenstra-Lenstra-Lovász algorithm）があります。LLLアルゴリズムは多項式時間で動作し、格子基底をある程度「良い基底」に簡約（Reduction）することができます。しかし、LLLアルゴリズムが見つけることができる最短ベクトルは、真の最短ベクトルの長さに対して指数関数的（$2^{\mathcal{O}(n)}$）な近似係数を持つため、暗号の安全性を破るには至りません。

LLLを改良したBKZ（Block Korkine-Zolotarev）アルゴリズムなどのより強力な基底簡約アルゴリズムを用いれば、より短いベクトルを見つけることができますが、その計算量はブロックサイズに対して指数関数的に増大します。格子暗号では、このBKZアルゴリズムの実行時間を見積もることで、安全なパラメータ（次元 $n$ の大きさなど）を決定しています。現在のPQCの標準パラメータでは、次元 $n$ は500から1000以上の値が選ばれており、スーパーコンピュータや将来の量子コンピュータを用いても解読には宇宙の年齢以上の時間がかかるとされています。

4. LWE問題（Learning With Errors）の数学的定式化

現代の格子暗号の大部分は、2005年にOded Regevによって提唱された「LWE問題（Learning With Errors）」をベースにしています。LWE問題の美しさは、その定式化のシンプルさと、「最悪時計算量から平均時計算量への帰着」という強力な数学的証明を持っている点にあります。

4.1 ノイズなしの連立一次方程式

LWE問題を理解するために、まずはノイズのない単純な連立一次方程式を考えてみましょう。未知の秘密ベクトル $\mathbf{s} \in \mathbb{Z}_q^n$ （各成分は $0$ から $q-1$ の整数）があるとします。ここで $q$ は素数とします。

ランダムな係数ベクトル $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$ を選び、秘密ベクトル $\mathbf{s}$ との内積を法 $q$ で計算します。 $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

十分な数（$n$個以上）の $(\mathbf{a}_i, b_i)$ のペアを与えられた場合、私たちは線形代数における「ガウスの消去法（Gaussian elimination）」を用いることで、容易に秘密ベクトル $\mathbf{s}$ を復元することができます。これは多項式時間で簡単に解ける問題です。

4.2 LWE問題の定義：ノイズを加える

では、この問題にわずかな「ノイズ（誤差）」を加えたらどうなるでしょうか？これがLWE問題の本質です。

未知の秘密ベクトル $\mathbf{s} \in \mathbb{Z}_q^n$ に対して、各方程式の結果に小さな誤差 $e_i \in \mathbb{Z}_q$ を加えます。 $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

ここで、$e_i$ は平均0、標準偏差が比較的小さい（例えば正規分布のような、離散ガウス分布から選ばれた）小さな整数値です。与えられる情報は、ランダムなベクトル $\mathbf{a}_i$ と、それに誤差を加えて計算された $b_i$ のペアのリストです。 $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

これを行列で表現すると非常にスッキリします。ランダムな行列 $A \in \mathbb{Z}_q^{m \times n}$、秘密ベクトル $\mathbf{s} \in \mathbb{Z}_q^n$、誤差ベクトル $\mathbf{e} \in \mathbb{Z}_q^m$ を用いて、

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

と書けます。与えられるのは $A$ と $\mathbf{b}$ のみです。ここから $\mathbf{s}$ を求めるのが「探索LWE問題（Search LWE problem）」です。

誤差 $e_i$ が入っているため、ガウスの消去法を使おうとすると、方程式を足し引きする過程で誤差が指数関数的に増幅してしまい、正しい答えに辿り着くことができなくなります。一見すると単純な連立一次方程式に見えますが、この小さなノイズが加わるだけで、問題の難易度がNP困難なレベルへと跳ね上がるのです。

4.3 決定LWE問題（Decision LWE）

暗号理論の証明において頻繁に用いられるのは、探索LWE問題のバリエーションである「決定LWE問題（Decision LWE problem）」です。

決定LWE問題とは、以下の2つの分布から得られたサンプルのリストを与えられたとき、それがどちらの分布から来たものかを判定する問題です。

LWE分布: 意図的に計算された $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
一様ランダム分布: 完全にランダムに選ばれた行列 $A$ とベクトル $\mathbf{u}$ からなる $(A, \mathbf{u})$

驚くべきことに、LWE問題のパラメータを適切に選べば、LWE分布から得られたペアは、完全にランダムなデータのペアと「計算量的に識別不可能（Computationally Indistinguishable）」になります。この性質が、LWEベースの暗号が「乱数と区別がつかない暗号文」を生成できる根拠となっています。

4.4 最悪時計算量から平均時計算量への帰着（Regevの定理）

Oded Regevの最大の功績は、このLWE問題の難しさを、前述の格子問題（SVPやCVP）の難しさに数学的に結びつけたことです。

彼は量子還元（Quantum reduction）を用いて、「もしLWE問題を平均的に（ランダムに選ばれた $A$ と $\mathbf{e}$ に対して）解くことができる多項式時間のアルゴリズムが存在するならば、任意の格子の最悪ケース（最も難しいケース）のGap-SVPを解くことができる多項式時間の量子アルゴリズムが存在する」ということを証明しました。（後に、Peikertらによって古典的な還元も示されています）。

これは暗号理論において夢のような性質です。なぜなら、「暗号が破られるのは、我々がたまたま弱い鍵（平均的なケースの一部）を選んでしまったからかもしれない」という懸念を払拭し、「平均的なLWEが解けるなら、格子の全ての難しい問題が解けてしまう（だからLWEは絶対に難しい）」という強力な保証を与えてくれるからです。

graph TD A["Worst-case Lattice Problems (Gap-SVP, SIVP)"] -->|Quantum/Classical Reduction| B["Average-case LWE Problem"] B -->|Cryptographic Construction| C["LWE-based Cryptosystems (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. LWEを用いた公開鍵暗号方式（Regev暗号）の構築

LWE問題の困難性を理解したところで、それを使ってどのように暗号化と復号を行うのか、Oded Regevが提案した基本的な公開鍵暗号方式を見ていきましょう。ここでは、1ビットのメッセージ $M \in \{0, 1\}$ を暗号化する最も基本的な仕組みを解説します。

5.1 鍵生成（Key Generation）

システムパラメータとして、法となる素数 $q$、次元 $n$、方程式の数 $m$（$m > n \log q$）を決定します。
秘密鍵として、ベクトル $\mathbf{s} \in \mathbb{Z}_q^n$ をランダムに選びます。
ランダムな行列 $A \in \mathbb{Z}_q^{m \times n}$ を生成します。
小さな誤差ベクトル $\mathbf{e} \in \mathbb{Z}_q^m$ を離散ガウス分布などの誤差分布から選びます。
ベクトル $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$ を計算します。
公開鍵（Public Key）は $(A, \mathbf{b})$ となります。
秘密鍵（Secret Key）は $\mathbf{s}$ となります。

公開鍵はまさに「LWE問題のインスタンス」そのものです。公開鍵 $(A, \mathbf{b})$ から秘密鍵 $\mathbf{s}$ を求めることは、探索LWE問題を解くことに等しいため、安全性が保証されます。

5.2 暗号化（Encryption）

アリスはボブの公開鍵 $(A, \mathbf{b})$ を用いて、1ビットのメッセージ $M \in \{0, 1\}$ を暗号化します。

ランダムなバイナリベクトル（成分が0か1）$\mathbf{r} \in \{0, 1\}^m$ を選びます。
暗号文の前半部分として、ベクトル $\mathbf{u} = A^T \mathbf{r} \pmod q$ を計算します。（$A^T$ は $A$ の転置行列です。つまり、$A$ の行のうち、$\mathbf{r}$ の成分が1である行を足し合わせています）。
暗号文の後半部分として、スカラー $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$ を計算します。（メッセージ $M$ が0なら何も足さず、$1$ なら $q$ のちょうど半分の値 $\lfloor \frac{q}{2} \rfloor$ を足します）。
暗号文（Ciphertext）は $(\mathbf{u}, v)$ となります。

暗号化の直観的な意味合いは、公開鍵の行列 $A$ とベクトル $\mathbf{b}$ に対して、「ランダムな部分集合の和」をとることです。決定LWE問題の困難性により、この暗号文 $(\mathbf{u}, v)$ は、完全にランダムなベクトルと一様乱数と区別がつかないように見えます（意味的安全性：Semantic Security）。

flowchart LR M["Message M in {0,1}"] --> Enc PK["Public Key (A, b)"] --> Enc r["Random binary vector r"] --> Enc subgraph Enc ["Encryption Process"] 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["Ciphertext (u, v)"]

5.3 復号（Decryption）

ボブは秘密鍵 $\mathbf{s}$ を用いて暗号文 $(\mathbf{u}, v)$ を復号します。

次の値を計算します： $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
計算した結果が、$0$ に近ければ $M=0$、$\lfloor \frac{q}{2} \rfloor$ に近ければ $M=1$ として出力します。

なぜこれで復号できるのか、数学的に展開してみましょう。 $\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} $$

ここで、式の中から $\mathbf{s}^T A^T \mathbf{r}$ が綺麗に相殺されて消えました！残ったのは $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$ です。

$\mathbf{e}$ は成分が非常に小さなノイズベクトルであり、$\mathbf{r}$ は成分が0か1のバイナリベクトルです。したがって、それらの内積である $\mathbf{e}^T \mathbf{r}$ も、（パラメータを適切に選べば）比較的小さな値に留まります。

もし $M=0$ ならば、結果は $\mathbf{e}^T \mathbf{r}$ となり、$0$ に近い小さな値になります。
もし $M=1$ ならば、結果は $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$ となり、$q$ の半分の値 $\lfloor \frac{q}{2} \rfloor$ の周辺に位置することになります。

誤差 $\mathbf{e}^T \mathbf{r}$ の絶対値が $\frac{q}{4}$ 未満に収まるようにパラメータが設計されていれば、ボブは計算結果が $0$ と $\lfloor \frac{q}{2} \rfloor$ のどちらに近いかを見るだけで、メッセージ $M$ を正確に判定（復号）することができます。これがLWEベースの暗号が機能する美しいメカニズムです。

flowchart LR CT["Ciphertext (u, v)"] --> Dec SK["Secret Key s"] --> Dec subgraph Dec ["Decryption Process"] direction TB calc["Compute D = v - s^T * u mod q"] check["Check if D is closer to 0 or q/2"] end calc --> check Dec --> M_out["Recovered Message M"]

6. 具体的な数値を用いたLWE暗号のトイ・エグザンプル

数式の羅列だけでは実感が湧きにくいと思いますので、実際に非常に小さな数値パラメータを設定して、暗号化から復号までの計算を追ってみましょう。（※現実の暗号システムでは、安全性確保のため $n$ は500以上、$q$ は数千以上の値が使われます）

【パラメータ設定】

法 $q = 17$ （素数。したがって値は $0$ から $16$ の範囲をとります）
次元 $n = 2$
方程式の数 $m = 4$
メッセージ $M = 1$ を暗号化するとします。
メッセージのシフト量：$\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

【1. 鍵生成フェーズ】 ボブは秘密鍵 $\mathbf{s}$ と行列 $A$、誤差ベクトル $\mathbf{e}$ をランダムに選びます。

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

次に公開鍵 $\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} $$

これを法 17 で計算します。($66 = 17 \times 3 + 15$ など)

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

誤差ベクトル $\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} $$

公開鍵は $A$ と $\mathbf{b} = (16, 0, 11, 1)^T$ となります。

【2. 暗号化フェーズ】 アリスはメッセージ $M = 1$ を暗号化します。ランダムなベクトル $\mathbf{r}$ を選びます。ここでは $\mathbf{r} = (1, 0, 1, 0)^T$ とします。

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

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

メッセージ $M=1$ に対応する値 $\lfloor 17/2 \rfloor = 8$ を足します。

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

アリスは暗号文として $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ をボブに送信します。

【3. 復号フェーズ】 暗号文を受け取ったボブは、秘密鍵 $\mathbf{s} = (3, 4)^T$ を用いて復号します。復号処理式： $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} $$

ここで、法17の世界では $-8$ は $9$ に等しくなります（$-8 + 17 = 9$）。得られた値 $D = 9$ を、$0$ と $8$（$\lfloor 17/2 \rfloor$）のどちらに近いか判定します。 $9$ は $0$ よりも $8$ に明らかに近いため、ボブは正しく $M = 1$ を復元することができました！

なぜ $9$ になったのでしょうか？先ほどの証明を思い出しましょう。誤差部分は $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$ となっています。したがって、計算結果は $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$ となり、理論通りの値が計算されていることが確認できました。

7. 実用化に向けた進化：Ring-LWE と Module-LWE

これまで説明してきた標準的なLWE問題（Standard LWE）は、非常に強力な安全性証明を持っていますが、実用上において致命的な弱点があります。それは「鍵のサイズが巨大になること」と「計算コストが高いこと」です。

Standard LWEでは、公開鍵に巨大な行列 $A \in \mathbb{Z}_q^{m \times n}$ が含まれます。パラメータ $n$ が数百〜数千になると、この行列のサイズは数メガバイトに達してしまい、インターネット上の通信プロトコル（TLSなど）で毎回送受信するには重すぎます。また、行列とベクトルの乗算には $\mathcal{O}(n^2)$ の計算量がかかります。

この問題を解決するために導入されたのが、多項式環（Polynomial rings）という代数的な構造を格子に組み込んだ「Ring-LWE（RLWE）」や「Module-LWE（MLWE）」です。

7.1 Ring-LWEの直観

Ring-LWEでは、ベクトルや行列を、多項式環 $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$ 上の要素（多項式）に置き換えます。（ここで $n$ は2の冪乗が選ばれます）。

Standard LWEの公開鍵が行列 $A$ であったのに対し、Ring-LWEでは単一の多項式 $a(x)$ を用います。秘密鍵 $s(x)$ や誤差 $e(x)$ も多項式になります。方程式は以下のようになります。

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

これは多項式の掛け算なので、高速フーリエ変換（FFT）に類似した「数論変換（Number Theoretic Transform: NTT）」を用いることで、計算量を $\mathcal{O}(n \log n)$ にまで劇的に削減できます。さらに、公開鍵のサイズも行列から単一の多項式へと小さくなるため、データサイズが $\mathcal{O}(n)$ に削減されます。これは通信帯域において圧倒的な優位性をもたらします。

数学的に見ると、Ring-LWEは一般的な格子ではなく、「イデアル格子（Ideal Lattice）」と呼ばれる特殊な対称性を持った格子上の問題に帰着します。

7.2 Module-LWEとNISTの標準化（Kyber / ML-KEM）

Ring-LWEは効率的ですが、イデアル格子の特殊な代数的構造が将来的な攻撃の糸口になるのではないかという一抹の懸念がありました。そこで、Standard LWEの保守的な安全性とRing-LWEの効率性の「いいとこ取り」をしたのが「Module-LWE（MLWE）」です。

Module-LWEでは、多項式を要素とする小さな行列とベクトルを考えます。つまり、環上のモジュール（加群）を扱います。現在、NISTがPQCの鍵共有アルゴリズム（KEM）の標準として選定した「CRYSTALS-Kyber」（標準化名称：ML-KEM）は、まさにこのModule-LWE問題の困難性に基づいて構築されています。

8. なぜ量子コンピュータに対して安全なのか？

最後に、「なぜ格子暗号は量子コンピュータを用いても解読されないと考えられているのか？」という核心部分に触れておきます。

量子コンピュータがRSA暗号や楕円曲線暗号を破るShorのアルゴリズムは、本質的には「隠れ部分群問題（Hidden Subgroup Problem: HSP）」を解くアルゴリズムです。RSAやECCの背景にある数学的構造（有限アーベル群）は周期性を持っており、量子フーリエ変換（QFT）という量子アルゴリズム特Actions:特有の操作を用いることで、この周期（隠れた部分群）を一気に抽出することができます。

しかし、格子問題は根本的に異なります。格子にも周期性はありますが、SVPやCVPで求められているのは「最短の距離」や「ノイズの除去」という幾何学的な非線形な性質です。Shorのアルゴリズムのような「アーベル群上の量子フーリエ変換」をそのまま適用しても、格子問題の解答となる有用な情報を効率的に抽出することができません。現在までに、SVPやLWEに対して多項式時間で解くことができる量子アルゴリズムは発見されておらず、量子コンピュータの並列計算能力をもってしても総当たりに近い探索（グローバーのアルゴリズムによる平方根の高速化程度）しか有効な手段がないと広く信じられています。

9. まとめ

本記事では、格子暗号の数学的直観について、格子の幾何学的定義から始まり、LWE問題の定式化、そして公開鍵暗号の構築に至るまで詳細に解説しました。

格子（Lattice） は、基底ベクトルの整数係数線形結合で表される離散的な空間であり、高次元においては直交に近い「良い基底」を見つけること（SVP）が困難になります。
LWE問題（Learning With Errors） は、ノイズ付きの連立一次方程式を解く問題であり、これが格子の最悪ケース問題の困難性に結びついているため、強力な安全性の根拠を提供します。
LWE問題を利用することで、ノイズを意図的に加えたり消去したりする巧妙な仕組みにより、暗号化と復号（Regev暗号）が実現されます。
現実のプロトコルでは、通信効率と計算速度を高めるために多項式環を用いた Ring-LWE や Module-LWE が採用されており、NIST標準の ML-KEM の基盤となっています。

量子コンピュータという未曾有の計算パラダイムシフトが迫る中、古典的な線形代数と整数論の深淵から生まれた「格子暗号」が、未来のインターネットセキュリティの基盤を担うというのは非常にロマンのある話です。格子暗号の基礎となる数学は決して難解すぎるものではなく、線形代数と確率の基礎知識があれば十分にその美しい構造を理解することができます。本記事が、PQCの核となる格子暗号の理解への一助となれば幸いです。

リーマン予想と素数の分布：現代暗号技術との深い関係

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

1. はじめに：素数という宇宙の神秘とリーマン予想

「素数（Prime Numbers）」は、1と自分自身でしか割り切れない自然数であり、数学の世界における「原子」とも呼ばれます。2, 3, 5, 7, 11, 13… と続くこの数列は、一見すると無秩序でランダムに現れるように見えます。古代ギリシャの数学者ユークリッドが「素数が無限に存在すること」を証明して以来、数え切れないほどの数学者たちがこの素数の並びに潜む規則性を解き明かそうと挑んできました。

その素数の謎に最も肉薄したのが、1859年にドイツの数学者ベルンハルト・リーマン（Bernhard Riemann）が提唱した**「リーマン予想（Riemann Hypothesis）」**です。リーマン予想は、現代数学において最も重要かつ未解決の難問の一つであり、クレイ数学研究所が定めるミレニアム懸賞問題の一つとして100万ドルの賞金が懸けられています。

一見すると、素数の分布に関する純粋数学の難問は、私たちの日常生活とは無縁に思えるかもしれません。しかし、現代社会のインフラを支えるインターネットのセキュリティ、特にRSA暗号や楕円曲線暗号（ECC）といった現代暗号技術は、巨大な素数の性質に深く依存しています。

本記事では、素数の分布から素数定理、リーマンゼータ関数、そしてリーマン予想の核心へと至る数学的な旅をし、それがどのようにして現代暗号技術と結びついているのか、そしてもしリーマン予想が証明されたら世界はどうなるのかについて、極めて詳細かつ深く掘り下げて解説します。

2. 素数定理と素数の分布：ガウスの発見

素数がどのように分布しているのかを理解するために、数学者たちは「ある数 $x$ 以下の素数がいくつ存在するか」を表す素数計数関数（Prime-counting function） $\pi(x)$ を考えました。

例えば：

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

15歳の天才数学者カール・フリードリヒ・ガウス（Carl Friedrich Gauss）は、膨大な素数の表を計算し、素数の出現頻度が自然対数 $\ln x$ に反比例して減少していくことを見出しました。つまり、ある数 $x$ の付近で素数が見つかる確率は約 $\frac{1}{\ln x}$ であると予想したのです。

これを積分を用いて表現したものが、対数積分（Logarithmic integral） $\text{Li}(x)$ です。

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

ガウスの予想は、後に1896年にジャック・アダマールとシャルル＝ジャン・ド・ラ・ヴァレ・プーサンによって独立に証明され、**素数定理（Prime Number Theorem, PNT）**として確立されました。

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

または近似的に以下のように表されます。

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

この定理により、素数は巨視的に見れば非常に滑らかで予測可能な分布を持っていることがわかりました。しかし、微視的に見れば $\pi(x)$ と $\text{Li}(x)$ の間には常に「誤差」すなわち「揺らぎ」が存在します。この揺らぎの正体こそが、リーマン予想が解き明かそうとしている最大のミステリーなのです。

3. リーマンゼータ関数とオイラー積

素数の分布を解析する上で最強の武器となるのが**リーマンゼータ関数（Riemann Zeta Function）**です。もともとはレオンハルト・オイラー（Leonhard Euler）によって実数 $s > 1$ に対して定義された無限級数でした。

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

オイラーの最大の功績の一つは、この無限級数が、すべての素数 $p$ に関する無限積として表せることを証明したことです。これが**オイラー積（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 $$

証明の直感的な理解は、右辺の各項を等比級数として展開し、それらを掛け合わせると、算術の基本定理（すべての自然数は素数の積として一意に表される）により、左辺の自然数の逆数和が完全に再構築されるというものです。

このたった一つの数式が、解析学（無限級数・連続関数）と数論（素数・離散的な数）を繋ぐ架け橋となりました。 ゼータ関数を調べることは、素数の分布を調べることと同義なのです。

4. 解析接続と複素平面への拡張

リーマンの天才性は、オイラーが実数のみで考えていた $\zeta(s)$ の変数 $s$ を、**複素数 $s = \sigma + it$（$\sigma$ は実部、$t$ は虚部）**に拡張したことにあります。

もともとの無限級数は $\sigma > 1$ でしか収束しませんが、リーマンは「解析接続（Analytic Continuation）」という手法を用いて、$s = 1$ の極を除外した全複素平面上で $\zeta(s)$ が意味を持つように定義を拡張しました。

彼はさらに、ゼータ関数が満たす美しい関数等式（Functional equation）を導き出しました。

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

ここで $\Gamma(x)$ はガンマ関数です。この等式により、右半平面の性質から左半平面の性質を知ることができます。

零点（Zeros of the Zeta Function）

ゼータ関数の値が 0 になる複素数 $s$ を「零点」と呼びます。関数等式から、$s$ が負の偶数（$-2, -4, -6, \dots$）のとき、$\sin(\pi s / 2)$ が 0 になるため、$\zeta(s) = 0$ となります。これらは**自明な零点（Trivial zeros）**と呼ばれます。

しかし、素数の分布において重要なのは、それ以外の零点、すなわち $0 \le \sigma \le 1$ の「臨界領域（Critical strip）」に存在する**非自明な零点（Non-trivial zeros）**です。

5. リーマン予想の核心と明示公式

リーマンは、少数の零点を計算し、ある驚くべき予想を立てました。これがリーマン予想です。

リーマン予想 (Riemann Hypothesis) リーマンゼータ関数 $\zeta(s)$ の非自明な零点はすべて、実部が $1/2$ の直線上（$\text{Re}(s) = 1/2$）に存在する。

この実部が1/2の直線を「臨界線（Critical line）」と呼びます。

graph TD A["リーマンゼータ関数 ζ(s)"] --> B["解析接続による複素数平面への拡張"] B --> C["自明な零点 (s = -2, -4, -6 ...)"] B --> D["非自明な零点 (0 <= Re(s) <= 1)"] D --> E["リーマン予想"] E --> F["すべての非自明な零点は Re(s) = 1/2 上にある"] F --> G["素数分布の誤差項の極限の証明へ"]

なぜリーマン予想がそれほど重要なのでしょうか？それは、ゼータ関数の零点が素数の分布を完全に決定しているからです。

リーマンと後の数学者フォン・マンゴルトは、素数の分布を正確に記述する「明示公式（Explicit formula）」を導きました。チェビシェフ関数 $\psi(x)$ を用いると、以下のように表されます。

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

ここで $\rho$ はゼータ関数の非自明な零点をすべてわたる和です。主項は $x$ （これは素数定理に対応）であり、そこから零点 $\rho$ に依存する波のような項を足し引きすることで、素数の階段状の正確な分布が復元されるのです。非自明な零点は、素数の分布の「周波数（波）」を表していると言えます。

もしリーマン予想が正しく、すべての非自明な零点 $\rho$ の実部がちょうど $1/2$ であるならば、素数定理の誤差項は理論上考えうる最小の範囲に収まることになります。

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

つまり、リーマン予想が真であれば、素数は私たちが想像し得る限り最も「規則正しく、美しく」分布していることが証明されるのです。

6. 現代暗号技術と素数の不可分な関係

ここまでは深遠な純粋数学の世界でしたが、この素数の性質は現代のデジタル社会を根底から支えています。その代表がRSA暗号をはじめとする公開鍵暗号方式です。

インターネットでのクレジットカード決済、パスワードの送信、ブロックチェーンの電子署名など、あらゆる通信の安全性は「素数」に依存しています。

RSA暗号の仕組み

RSA暗号の安全性は、「桁数の大きい合成数の素因数分解は非常に困難である」という数学的事実（素因数分解問題）に基づいています。

鍵生成: 巨大な素数 $p$ と $q$ （例えばそれぞれ2048ビット）をランダムに選びます。それらを掛け合わせて $N = p \times q$ を計算します。この $N$ が公開鍵の一部となります。オイラーのトーティエント関数 $\phi(N) = (p-1)(q-1)$ を用いて、秘密鍵 $d$ を生成します。
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
暗号化と復号: 平文 $M$ は、公開鍵 $e, N$ を用いて暗号文 $C$ に変換されます。
$$ C \equiv M^e \pmod{N} $$
秘密鍵 $d$ を持つ者だけが、復号できます。
$$ M \equiv C^d \pmod{N} $$

graph LR A["平文 (Plaintext)"] --> B["公開鍵(e, N)で暗号化"] B --> C["暗号文 (Ciphertext)"] C --> D["秘密鍵(d)で復号"] D --> E["元の平文"] F["攻撃者 (Attacker)"] -- "Nの素因数分解を試みる" --> C F -.-> G["pとqが分からないとdは計算不能"]

RSA暗号を破るためには、巨大な $N$ から元の素数 $p$ と $q$ を見つけ出す（素因数分解する）必要があります。現在主流のアルゴリズム（一般数体篩法：GNFSなど）を用いても、何百桁もの数を素因数分解するには、スーパーコンピュータを使っても宇宙の年齢をはるかに超える時間がかかるとされています。

7. リーマン予想が暗号技術に与えるインパクト

では、純粋数学の頂点にある「リーマン予想」と「暗号技術」はどのように交差するのでしょうか？

7.1. 素数生成アルゴリズム（素数判定）と拡張リーマン予想（GRH）

RSA暗号を運用するためには、最初に巨大な素数 $p$ と $q$ を生成する必要があります。しかし、「ある数が素数かどうか」を確実かつ高速に判定するのは簡単ではありません。

現在、実用的に使われているのは**ミラー・ラビン素数判定法（Miller-Rabin primality test）**という確率的アルゴリズムです。このアルゴリズムは高速ですが、極めて低い確率で合成数を素数と誤判定する「擬素数」のリスクがあります。

しかし、リーマン予想をディリクレのL関数に拡張した**「拡張リーマン予想（Generalized Riemann Hypothesis, GRH）」が真であると仮定すると、話は劇的に変わります。 GRHが真であれば、ミラー・ラビン判定法におけるテスト回数の上限が数学的に保証され、確率的アルゴリズムから「決定性多項式時間アルゴリズム」へと昇華**するのです（これは、AKS素数判定法が発見される以前から知られていた重大な事実でした）。

つまり、リーマン予想（およびその拡張）は、「巨大な素数を絶対の自信を持って高速に生成できるか」という暗号の基盤生成に直接的なお墨付きを与える役割を持っています。

7.2. 素因数分解アルゴリズムとの関係

暗号を解読する側のアルゴリズム（一般数体篩法など）の計算量を評価する際にも、素数の分布に関する知識が不可欠です。素因数分解アルゴリズムの多くは「滑らかな数（Smooth numbers：小さな素因数しか持たない数）」の分布に依存しています。

滑らかな数がどの程度の頻度で現れるかを厳密に評価するためには、素数の分布に関する深い理解が必要であり、ここでもゼータ関数やリーマン予想に直結する解析的整数論のテクニックが駆使されています。リーマン予想が証明され、素数分布の誤差が完全に決定されれば、素因数分解アルゴリズムの性能限界もより正確に見極めることが可能になります。

8. もしリーマン予想が証明されたら、暗号は破られるのか？

都市伝説のように「リーマン予想が解けたらRSA暗号は一瞬で崩壊する」と語られることがありますが、これは数学的には不正確です。

リーマン予想の証明自体が、直ちに素因数分解を劇的に高速化する魔法のアルゴリズムを生み出すわけではありません。リーマン予想はあくまで素数の「巨視的な分布の規則性」についての定理であり、個別の数 $N$ がどの素数で割り切れるか（局所的な性質）を直接教えてくれるものではないからです。

しかし、影響はゼロではありません。リーマン予想が証明される過程で、「新たな数学的ツール」や「未知の解析手法」が発見される可能性が極めて高いからです。歴史を見ても、フェルマーの最終定理やポアンカレ予想が証明された際、その過程で開発された新しい理論が数学全体を大きく飛躍させました。

もしリーマンゼータ関数の零点の性質を完全に操作できる未知の代数幾何学的手法や、非可換幾何の手法が確立されれば、それが結果として素因数分解の画期的なアルゴリズム（例えば、計算量を多項式時間に落とし込むような古典アルゴリズム）の発見に繋がる可能性は否定できません。その意味で、暗号学者はリーマン予想の動向から決して目を離すことができないのです。

量子コンピュータとショアのアルゴリズム

暗号技術にとってより直接的で現実的な脅威は、リーマン予想の証明ではなく量子コンピュータです。1994年にピーター・ショア（Peter Shor）が発表した「ショアのアルゴリズム」は、十分な性能を持つ量子コンピュータがあれば、素因数分解を多項式時間で解けることを証明しました。これにより、RSA暗号や楕円曲線暗号は根本的に破られることになります。

現在、世界中で量子コンピュータでも解読できない「耐量子計算機暗号（Post-Quantum Cryptography, PQC）」への移行（格子暗号など）が進められています。素数に依存した暗号技術は、ある意味で黄金期を終えようとしているのかもしれませんが、素数そのものの数学的価値が失われることは永遠にありません。

9. 結び：数学の抽象性と現実社会の交差点

graph TD A["純粋数学の探求"] --> B["リーマン予想の解明"] B --> C["素数分布の完全な理解"] C --> D["数論・代数幾何学の飛躍的発展"] D -.-> E["新しい素因数分解アルゴリズムの可能性"] E -.-> F["暗号技術の安全性評価の更新"] A --> G["応用数学・計算機科学"] G --> H["素数判定・暗号生成の効率化"] H --> F

古代ギリシャから続く素数への飽くなき探求は、リーマンという天才によって複素数平面上の美しいシンフォニー（ゼータ関数の零点）へと昇華されました。そして驚くべきことに、その純粋無垢な数学の結晶が、数世紀の時を経てインターネット社会の安全を担保する最強の盾として応用されています。

リーマン予想は、数学が持つ「抽象的な美しさ」と「物理世界・現実社会への驚異的な適用力」を同時に象徴する存在です。

未だ誰も頂上に到達していないこの巨大な数学の山がいつの日か征服されたとき、私たちは素数という宇宙の真理を完全に理解するとともに、情報化社会の基盤に対して新たな視点を持つことになるでしょう。暗号技術を学ぶことは、そのまま人類の英知の歴史を辿る旅でもあるのです。

C++で実装する高速な素数判定アルゴリズム（Miller-Rabin法など）

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

はじめに：なぜ高速な素数判定が必要なのか

情報科学や暗号理論、あるいは競技プログラミングの世界において、「ある数が素数であるかどうか」を高速かつ正確に判定することは、非常に重要で基礎的な課題です。例えば、現代のインターネット社会のセキュリティを支えているRSA暗号などの公開鍵暗号方式は、巨大な素数の生成とその掛け算の困難性（素因数分解の難しさ）を安全性の根拠としています。したがって、巨大な数が素数であるかを瞬時に見分ける技術は、デジタル社会の根幹を支える技術と言っても過言ではありません。

また、競技プログラミング（AtCoderやCodeforcesなど）においても、素数判定は頻出のテーマです。制約が $N \le 10^{18}$ といった巨大な入力に対して、1秒以内で素数判定を数万回行うようなシチュエーションでは、伝統的で素朴なアルゴリズムでは到底計算時間（Time Limit Exceeded: TLE）に間に合いません。

本記事では、素朴な素数判定アルゴリズムから始まり、確率的素数判定法である「フェルマーテスト」、そしてその弱点を克服した実用上最強レベルの高速アルゴリズム「ミラー・ラビン（Miller-Rabin）素数判定法」について、数学的な背景からC++による高度に最適化された実装まで、徹底的に解説します。特に、64ビット整数（$N < 2^{64}$）に対しては、確率的な判定にとどまらず「100%確実に素数判定ができる（決定論的判定）」手法についても詳しく説明し、実践でそのまま使えるC++のソースコードを提供します。

1. 素数判定の基礎と試し割り法 (Trial Division)

素数（Prime number）とは、1と自分自身以外に正の約数を持たない、2以上の自然数のことです。素数の定義に忠実に従えば、ある整数 $N$ が素数かどうかを判定するには、$2$ から $N-1$ までのすべての整数で $N$ を割ってみて、一度も割り切れなければ素数、一度でも割り切れれば合成数（素数でない）と判断できます。

しかし、この方法は計算量が $O(N)$ となり、$N$ が $10^{18}$ などの巨大な数の場合、現代のコンピュータでも計算に膨大な時間がかかってしまいます。

試し割り法の最適化：$\sqrt{N}$ までの探索

合成数 $N$ が $a \times b = N$ （$a \le b$）と表されるとき、必ず $a \le \sqrt{N}$ となります。したがって、素数判定のループは $N-1$ まで回す必要はなく、$\sqrt{N}$ まで調べれば十分です。

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


#include <iostream>

// 試し割り法による素数判定 (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // 3以上の奇数のみ調べる
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

このアルゴリズムの計算量は $O(\sqrt{N})$ です。$N \le 10^{12}$ 程度であれば一瞬で計算できますが、$N \approx 10^{18}$ の場合、ループ回数が約 $10^9$ 回となり、C++の処理系であっても数百ミリ秒から数秒の時間を要するため、複数回の判定には不向きです。

2. フェルマーテスト：確率的素数判定の幕開け

試し割り法の限界を突破するために考え出されたのが、数論の定理を用いた「確率的アルゴリズム（Probabilistic Algorithm）」です。その代表例が、フェルマーの小定理を利用した「フェルマーテスト（Fermat Primality Test）」です。

フェルマーの小定理 (Fermat’s Little Theorem)

ピエール・ド・フェルマー（Pierre de Fermat）が発見したこの定理は、次のように主張しています。

任意の素数 $p$ と、互いに素な（$p$ の倍数ではない）任意の整数 $a$ について、以下の合同式が成り立つ。
$$ a^{p-1} \equiv 1 \pmod p $$

この定理の対偶をとると、「ある整数 $N$ と、$N$ と互いに素な整数 $a$ に対して $a^{N-1} \not\equiv 1 \pmod N$ となるならば、$N$ は確実に合成数である」と言えます。この性質を利用して、判定対象の数 $N$ に対してランダムな底（base）$a$ を選び、$a^{N-1} \pmod N$ を計算して $1$ になるか確認するのがフェルマーテストです。

高速なべき乗剰余（繰り返し二乗法）

フェルマーテストを行うためには、$a^{N-1} \pmod N$ という巨大なべき乗を高速に計算する必要があります。これには「繰り返し二乗法（Modular Exponentiation / Binary Exponentiation）」を用います。計算量は $O(\log N)$ となり、非常に高速です。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 繰り返し二乗法を用いた a^b mod m の計算
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

※ ここではオーバーフローを防ぐため、GCC/Clangの拡張である __int128_t（128ビット整数）を使用して途中の積を保持しています。

疑似素数とカーマイケル数 (Carmichael Numbers)

フェルマーテストは非常に強力ですが、致命的な弱点があります。それは、$N$ が合成数であるにもかかわらず、すべての $a$ （$N$ と互いに素な $a$）に対して $a^{N-1} \equiv 1 \pmod N$ が成立してしまうような数が存在するということです。

このような数を「絶対疑似素数」または「カーマイケル数」と呼びます。最小のカーマイケル数は $561 = 3 \times 11 \times 17$ です。カーマイケル数が存在するため、フェルマーテストだけでは「確率100%」の決定論的判定を行うことができません。いくら異なる $a$ を試しても、$561$ のような数は常に素数のフリ（騙し）をしてしまいます。

3. ミラー・ラビン素数判定法 (Miller-Rabin Primality Test)

フェルマーテストの弱点（カーマイケル数の存在）を見事に克服したのが、ミラー（Gary L. Miller）とラビン（Michael O. Rabin）によって考案された「ミラー・ラビン素数判定法」です。現在、実用的な高速素数判定アルゴリズムとして、さまざまなプログラミング言語の内部ライブラリや暗号システムの鍵生成で最も広く使われています。

数学的原理

ミラー・ラビンのアルゴリズムは、フェルマーの小定理に加えて、「素数を法とする剰余体（$\mathbb{Z}/p\mathbb{Z}$）においては、$x^2 \equiv 1 \pmod p$ の解は $x \equiv 1$ または $x \equiv -1$ に限られる」という性質を利用します（合成数を法とする場合は、これ以外の非自明な平方根が存在し得ます）。

判定したい奇数 $N$ から $1$ を引いた $N-1$ は必ず偶数になります。そこで、$N-1$ を $2$ で割れるだけ割り、次のような形式で表します。

$$ N-1 = d \cdot 2^s $$

（ここで、$d$ は奇数、$s \ge 1$）

任意の底 $a$ （$1 < a < N-1$）について、$a^{N-1} \equiv 1 \pmod N$ であるかをフェルマーの小定理に従って検証しますが、その計算を段階的に行います。具体的には、$a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$ と順番に2乗を繰り返していきます。

ミラー・ラビンテストが $N$ を「素数である（あるいは強い確率で素数である）」と判定するための条件は、以下の いずれか が成立することです。

$a^d \equiv 1 \pmod N$
ある $r$ （$0 \le r < s$）が存在して、$a^{d \cdot 2^r} \equiv -1 \pmod N$ が成り立つ。 ※ C++のモジュロ演算では $-1 \pmod N$ は $N-1$ となります。

もし $N$ が素数であれば、任意の $a$ についてこの条件が必ず満たされます。逆に $N$ が合成数であれば、ランダムな $a$ を選んだとき、この条件を満たす確率（騙される確率）は $\frac{1}{4}$ 以下であることが数学的に証明されています。 $k$ 回の独立したテストを行えば、誤判定の確率は $\left(\frac{1}{4}\right)^k$ 以下となり、実用上ゼロとみなすことができます。カーマイケル数のような「絶対にごまかせる」数は存在しません。

ミラー・ラビン法のアルゴリズムの流れ（Mermaidフローチャート）

以下の図は、ミラー・ラビン素数判定法の1回のテスト（1つの底 $a$ に対するテスト）の論理的なフローを示しています。

graph TD Start["テスト開始 (入力: N, a)"] --> CalcDS["N-1 = d * 2^s を満たす d (奇数) と s を計算"] CalcDS --> CalcX["x = a^d mod N を計算"] CalcX --> CheckX1{"x == 1 または x == N-1 ?"} CheckX1 -- "Yes" --> ReturnTrue["素数の可能性がある (Probably Prime)"] CheckX1 -- "No" --> LoopStart["r = 1 から s-1 までループ開始"] LoopStart --> LoopCondition{"r < s ?"} LoopCondition -- "No" --> ReturnFalse["確実に合成数 (Composite)"] LoopCondition -- "Yes" --> SquareX["x = (x * x) mod N を計算"] SquareX --> CheckXMinus1{"x == N - 1 ?"} CheckXMinus1 -- "Yes" --> ReturnTrue CheckXMinus1 -- "No" --> CheckXOne{"x == 1 ?"} CheckXOne -- "Yes" --> ReturnFalse CheckXOne -- "No" --> LoopNext["r を 1 増加させて次へ"] LoopNext --> LoopCondition

4. 64ビット整数に対する決定論的判定

ミラー・ラビン素数判定法は本来「確率的」アルゴリズムですが、$N$ の上限が固定されている場合、特定の複数の $a$ （底）をすべて試すことで、「100%確実に」素数判定を行うことができます。これを 決定論的ミラー・ラビンテスト（Deterministic Miller-Rabin Test） と呼びます。

Jim Sinclairらの研究により、$N < 2^{64}$ （約 $1.8 \times 10^{19}$）のすべての整数に対しては、以下の $7$ つの素数を底 $a$ として選んでテストすれば、十分かつ完全に決定論的な判定が可能であることが判明しています。

テストすべき底 $a$ のリスト: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

あるいは、よく知られた別のセットとして、以下の $12$ 個の素数を使用することでも $N < 2^{64}$ 以下で完璧に判定できます。 {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

今回は、アルゴリズムの簡潔さと信頼性を高めるために、後者の $12$ 個の素数をベース（あるいはより最適化された $7$ つのベース）として用いる手法を採用します。C++の実装では、条件分岐で範囲を分けることで、テスト回数を最小限に抑える最適化を行います。

5. C++による高度な実装 (Highly Optimized C++ Implementation)

それでは、ここまでの数学的な理論とアルゴリズムの設計をまとめ上げ、現代のC++における最強レベルのミラー・ラビン素数判定関数の実装コードを提示します。

実装のポイント

64ビット整数の掛け算のオーバーフロー回避: $N \approx 10^{18}$ の場合、モジュロ乗算における $x \times x$ は最大 $10^{36}$ となり、通常の64ビット整数（uint64_t や long long）の最大値 $1.8 \times 10^{19}$ を軽々とオーバーフローしてしまいます。この問題を解決するため、GCCやClangの拡張型である __int128_t（あるいは unsigned __int128）を使用し、128ビット精度で計算を行った後にモジュロを取ります。これにより、複雑なアルゴリズムを使わずとも高速に剰余乗算が可能です。
決定論的ベースの選択: $N$ の値が小さい場合は、少しの底（base）をテストするだけで済むように最適化します。

完全なC++ソースコード

以下に、実戦投入可能な完成版のソースコードを示します。このコードは競技プログラミング等の環境にそのままコピーして利用可能です。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


#include <iostream>
#include <vector>
#include <cstdint>
#include <initializer_list>

using namespace std;

// 128ビット整数による高速な (a * b) mod m
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// 繰り返し二乗法による (base^exp) mod m の計算
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// ミラー・ラビン素数判定法による 64bit 整数の決定論的判定
bool is_prime_miller_rabin(uint64_t n) {
 // 境界値と小さな素数の事前判定
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // n-1 = d * 2^s の形に分解する
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // 判定に使用する底 (bases) のリスト
 // N の大きさに応じてテストするベースの数を最小限に抑える最適化
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // N < 2^64 のすべての数に対して決定論的となる 7 つの底
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // 各底についてテストを実行
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // a が n の倍数の場合は判定不能だが素数ではない

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // 第一条件クリア、次の底へ

 bool composite = true;
 // s-1 回のループ (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // 第二条件クリア、素数の可能性あり
 break;
 }
 }

 // どの条件も満たさなければ確実に合成数
 if (composite) return false;
 }

 // すべてのベースで条件をクリアした場合は確実に素数
 return true;
}

int main() {
 // テスト用のサンプル
 vector<uint64_t> test_cases = {
 1000000007, // 有名な素数
 998244353, // 有名な素数
 1000000000000000003, // 10^18近辺の素数
 1000000000000000007, // 合成数 (10^18 + 7)
 561, // カーマイケル数 (合成数)
 18446744073709551557ULL // 2^64 近辺の最大の素数の一つ
 };

 for (uint64_t n : test_cases) {
 cout << n << " is "
 << (is_prime_miller_rabin(n) ? "Prime" : "Composite")
 << endl;
 }

 return 0;
}

6. アルゴリズムの計算量とパフォーマンス評価

実装したアルゴリズムの性能について考察します。

時間計算量 (Time Complexity)

試し割り法: $O(\sqrt{N})$
フェルマーテスト: べき乗計算 $O(\log N) \times k$ （$k$ は試行回数）
ミラー・ラビン法: べき乗計算とループ $O(\log N) \times k$

64ビット環境（$N \le 2^{64}$）において、上記の決定論的ミラー・ラビン法は、最大でも $7$ つのベースしか検証しません。したがって、$k \le 7$ の定数とみなすことができ、全体の時間計算量は厳密に $O(\log N)$ となります。最大ケース（$N \approx 10^{19}$）であっても、実行ステップ数は高々 $7 \times 64 = 448$ ステップの基本演算に収まり、実行時間は数マイクロ秒（$10^{-6}$ 秒）以下です。試し割り法の $O(\sqrt{N})$ （ループ回数 $\approx 4 \times 10^9$ 回）と比較すると、数百万倍の高速化 が達成されています。

さらなる最適化：モンゴメリ乗算 (Montgomery Multiplication)

本記事の実装では、128ビット整数の拡張型 __int128_t を用いて除算（モジュロ演算 %）を行っています。現代のCPUであっても、整数除算（DIV命令）は加算や乗算に比べて数十サイクルを要するコストの高い命令です。

より極限の最適化を追求するライブラリ作成者や競技プログラマは、モンゴメリ乗算（Montgomery Multiplication） と呼ばれる手法を採用することがあります。モンゴメリ乗算は、数値を特殊な「モンゴメリ空間」に写像することで、高コストなモジュロ演算（除算）を「ビットシフトと乗算のみ」に置き換える驚異的なアルゴリズムです。これをミラー・ラビン判定の剰余乗算に組み込むことで、さらに実行速度を2倍から3倍程度引き上げることが可能です。これについては非常に奥深いテーマとなるため、別の記事で詳細に解説したいと思います。

7. まとめ

本記事では、素数判定の基礎から発展的な内容までを一挙に解説しました。ポイントを振り返りましょう。

試し割り法 は確実だが、計算量 $O(\sqrt{N})$ のため $N$ が $10^{12}$ を超えると実用性に欠ける。
フェルマーテスト は $O(\log N)$ と非常に高速だが、カーマイケル数などの絶対疑似素数に騙されるという致命的な弱点がある。
ミラー・ラビン素数判定法 は、フェルマーテストの弱点を解消した実用的で最強のアルゴリズム。
C++による実装では、__int128_t を活用することで 64ビット整数の乗算オーバーフローを安全に処理できる。
64ビット整数の範囲内（$N < 2^{64}$）であれば、$7$ 個または $12$ 個の特定の素数を底として選ぶことで、確率的ではなく決定論的（100%正確）に素数判定が可能。

高速な素数判定は、巨大な数を扱う計算において避けては通れない技術です。本記事で提供したC++のミラー・ラビンのソースコードは、そのまま実戦で活用できる堅牢なものになっています。ぜひ、ご自身のプロジェクトやアルゴリズム競技で活用してみてください。

graph LR TrialDivision["試し割り法 (O(√N))"] --> Fermat["フェルマーテスト (O(log N), 弱点あり)"] Fermat --> MillerRabin["ミラー・ラビン法 (O(log N), 決定論的化可能)"] MillerRabin --> Montgomery["+ モンゴメリ乗算 (定数倍高速化)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

プログラミングと数学が交差するアルゴリズムの世界は非常に美しく、奥深いものです。今後の学習の一助となれば幸いです。

Reference:

Pomerance, C., Selfridge, J. L., & Wagstaff, S. S. (1980). The pseudoprimes to 25.10^9. Mathematics of Computation.
Sinclair, J. (2011). Deterministic Miller-Rabin primality testing.

【数学解説】RSA暗号の仕組みを高校生でもわかるように説明する

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

インターネット社会の安全を根底から支えている技術の一つが「RSA暗号」です。オンラインショッピングでのクレジットカード決済、友人とのSNSのやり取り、会社の機密情報の送受信など、私たちが毎日何気なく使っている通信の多くは、このRSA暗号やその後継技術によって守られています。

しかし、「暗号」と聞くと、スパイ映画に出てくるような複雑な暗号機や、一部の天才しか理解できない超高度な数学を想像するかもしれません。確かに現代の暗号理論は高度な数学に基づいていますが、RSA暗号の根本的な仕組みは、高校で習う数学（整数の性質、素数、合同式など）の知識があれば十分に理解できるものです。

この記事では、高校数学の知識を出発点として、RSA暗号がどのような数学的原理で動いているのか、なぜ解読が難しいのかを、ステップバイステップで徹底的に解説します。数学が少し苦手な方でも理解できるように、具体例を交えながら丁寧に説明していきます。

1. 共通鍵暗号と公開鍵暗号

RSA暗号の数学的な仕組みに入る前に、まず暗号の基本的な考え方について整理しておきましょう。暗号方式は大きく分けて「共通鍵暗号」と「公開鍵暗号」の2種類があります。

1.1 共通鍵暗号方式の限界

昔から使われている暗号の多くは「共通鍵暗号方式」と呼ばれるものです。これは、「暗号化（メッセージを秘密の暗号文に変換すること）」と「復号（暗号文を元のメッセージに戻すこと）」に同じ鍵を使う方式です。

例えば、アリスがボブに秘密の手紙を送るとします。アリスは南京錠（共通鍵）を使って箱に手紙を入れて鍵をかけます。ボブがその箱を開けるためには、アリスが使ったのと同じ鍵を持っている必要があります。

この方式には大きな問題があります。「鍵の配送問題」です。遠く離れたアリスとボブが初めて通信する場合、どのようにして盗聴されることなく鍵を共有すればよいのでしょうか？もし鍵を郵送している途中で第三者に盗まれたら、その後の暗号通信はすべて筒抜けになってしまいます。

1.2 画期的な発明「公開鍵暗号方式」

この鍵の配送問題を解決するために考案されたのが「公開鍵暗号方式」です。RSA暗号もこの一種です。

公開鍵暗号方式では、「暗号化するための鍵（公開鍵）」と「復号するための鍵（秘密鍵）」という2つの異なる鍵を使います。

受信者のボブは、「公開鍵」と「秘密鍵」のペアを作成します。
ボブは「公開鍵」を世界中に公開します（誰が手に入れても構いません）。
送信者のアリスは、ボブの「公開鍵」を使ってメッセージを暗号化し、送信します。
暗号化されたメッセージは、ボブだけが持っている「秘密鍵」でしか復号できません。

これを南京錠で例えると、ボブは「開いた状態の南京錠（公開鍵）」をたくさん作って世界中にばらまきます。アリスはボブ宛のメッセージを箱に入れ、拾ったボブの南京錠でカチャッと鍵をかけます。南京錠は一度閉まると、ボブが持っている「マスターキー（秘密鍵）」でしか開けられません。途中で誰かが箱を盗んでも、マスターキーがないので開けられないのです。

graph TD A["アリス (送信者)"] --> B["平文 (メッセージ)"] B --> C["暗号化処理"] D["ボブの公開鍵 (誰でも入手可能)"] --> C C --> E["インターネット経由で送信: 暗号文"] E --> F["復号処理"] G["ボブの秘密鍵 (ボブだけが持つ)"] --> F F --> H["復元された平文 (メッセージ)"] H --> I["ボブ (受信者)"]

この画期的なシステムを実現するためには、「公開鍵で簡単に暗号化できるが、秘密鍵がないと絶対に復号できない」という、ある種の**「一方向性関数（一方通行の数学的パズル）」**が必要になります。そのパズルの部品として目をつけられたのが、私たちがよく知る「素数」でした。

2. RSA暗号を支える数学的基礎1：素数と素因数分解

RSA暗号の安全性は、**「巨大な数の素因数分解は非常に難しい」**という数学的事実に基づいています。

2.1 素数とは

素数とは、「1と自分自身でしか割り切れない、1より大きい自然数」のことです。例：$2, 3, 5, 7, 11, 13, 17, 19, 23...$

素数は、すべての整数の「原子」のようなものです。どんな自然数も、素数の掛け算の形に分解することができます。これを素因数分解と呼びます。例えば、$60 = 2^2 \times 3 \times 5$ のように、順番を無視すればただ一通りに素因数分解できることは「算術の基本定理」として知られています。

2.2 素因数分解の難しさ（一方向性関数）

ここで重要なのは、**「掛け算は簡単だが、素因数分解は難しい」**という非対称性です。

例えば、次の2つの素数の掛け算を暗算で計算してみてください。 $11 \times 13 = ?$ これは簡単ですね。答えは $143$ です。

では、次の数はどうでしょう？ $323$ を素因数分解してください。どうでしょうか？少し時間がかかるはずです。（答えは $17 \times 19$ です）。

数が小さければ人間でも何とか計算できますが、数が大きくなるとコンピュータを使っても計算が爆発的に難しくなります。現在主流のRSA暗号では、2048ビット（10進数で約600桁）という途方もなく巨大な素数 $p$ と $q$ を掛け合わせた数 $N = p \times q$ を使います。

2つの巨大な素数 $p$ と $q$ が与えられたとき、$N$ を計算するのはコンピュータにとって一瞬（ミリ秒以下）です。しかし、逆に $N$ だけを与えられて元の $p$ と $q$ を見つけ出すことは、現在の最速のスーパーコンピュータを何兆年回しても解けないほど時間がかかります。

この**「計算の非対称性（片道は簡単、逆道は困難）」**が、公開鍵と秘密鍵の関係性を作り出す土台になります。

3. RSA暗号を支える数学的基礎2：合同式（モジュロ演算）

RSA暗号の計算は、私たちが普段使っているような無限に数が大きくなる足し算や掛け算ではなく、ある数で割った「余り」の世界で行われます。これを**合同式（モジュロ演算）**と呼びます。

3.1 時計の数学

モジュロ演算はよく「時計の数学」に例えられます。現在10時だとして、そこから5時間後は何時でしょうか？ $10 + 5 = 15$ 時ですが、通常の12時間時計では「3時」と答えます。これは、15を12で割った余りが3だからです。

数学の世界では、これを次のように書き表します。

$$ 15 \equiv 3 \pmod{12} $$

「15と3は、12を法として合同である（12で割った余りが等しい）」と読みます。

3.2 合同式の基本的な性質

合同式には、等式（$=$）とよく似た非常に便利な性質があります。法（割る数）を $N$ とします。 $a \equiv b \pmod N$ かつ $c \equiv d \pmod N$ のとき、以下が成り立ちます。

足し算: $a + c \equiv b + d \pmod N$
引き算: $a - c \equiv b - d \pmod N$
掛け算: $a \times c \equiv b \times d \pmod N$
べき乗: $a^k \equiv b^k \pmod N$ （$k$ は自然数）

特に重要なのは「べき乗」の性質です。これは**「余りの累乗は、累乗の余りに等しい」**ことを意味します。例えば、$7^{100}$ を $5$ で割った余りを求めたいとします。真面目に $7$ を100回掛けてから $5$ で割るのは大変ですが、合同式の性質を使えば、$7 \equiv 2 \pmod 5$ なので、$7^{100} \equiv 2^{100} \pmod 5$ となり、計算を飛躍的に簡単にしていくことができます。暗号の世界では非常に大きな数の累乗を扱うため、この性質が不可欠です。

4. RSA暗号を支える数学的基礎3：オイラー関数とオイラーの定理

ここからがRSA暗号の核心となる魔法の数学です。「フェルマーの小定理」の一般化である「オイラーの定理」が登場します。

4.1 オイラーのトーティエント関数 $\phi(N)$

オイラーのトーティエント関数（$\phi$ 関数）は、ある自然数 $N$ に対して、**「1から $N$ までの自然数のうち、$N$ と互いに素（最大公約数が1）である数の個数」**を返す関数です。

いくつか例を見てみましょう。

$\phi(5)$: 1, 2, 3, 4, 5 の中で 5 と互いに素なのは 1, 2, 3, 4 の4個。よって $\phi(5) = 4$。
$\phi(6)$: 1, 2, 3, 4, 5, 6 の中で 6 と互いに素なのは 1, 5 の2個。よって $\phi(6) = 2$。

【素数の場合の特別な性質】 $p$ が素数の場合、1から $p-1$ までのすべての数が $p$ と互いに素になります。したがって、

$$ \phi(p) = p - 1 $$

となります。

【素数の積の場合の特別な性質】 2つの異なる素数 $p$ と $q$ について、$N = p \times q$ とした場合、$\phi(N)$ は以下の計算で簡単に求めることができます。

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

この性質が、RSA暗号の「秘密の裏口（トラップドア）」として機能します。$p$ と $q$ を知っている人（鍵の作成者）は $\phi(N)$ を一瞬で計算できますが、$N$ しか知らない第三者は、$N$ を素因数分解しない限り $\phi(N)$ を求めることができないのです。

4.2 オイラーの定理

レオンハルト・オイラーは、この $\phi(N)$ を使って次のような美しい定理を証明しました。

オイラーの定理： 整数 $a$ と $N$ が互いに素であるとき、以下の合同式が成り立つ。

$$ a^{\phi(N)} \equiv 1 \pmod N $$

これは、「ある数 $a$ を $\phi(N)$ 回掛け合わせて $N$ で割ると、余りが必ず $1$ になる」という驚くべき性質です。（$N$ が素数 $p$ の場合は $a^{p-1} \equiv 1 \pmod p$ となり、フェルマーの小定理と呼ばれます）。

このオイラーの定理を変形してみましょう。両辺に $a$ をもう一回掛けます。

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

さらに、任意の整数 $k$ に対して、$a^{k \cdot \phi(N)}$ も $1^k = 1$ になるため、次の式が成り立ちます。

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

この式こそが、RSA暗号の**「暗号化して復号すると元に戻る」**という魔法を成り立たせている根本原理なのです。

5. RSA暗号のアルゴリズム：鍵生成・暗号化・復号のステップ

基礎知識が揃ったところで、いよいよRSA暗号の具体的な手順を見ていきましょう。RSA暗号は大きく「1. 鍵の生成」「2. 暗号化」「3. 復号」の3つのフェーズに分かれます。

flowchart TD A1["1. 素数 p, q を選ぶ"] --> A2["N = p × q を計算"] A1 --> A3["φ(N) = (p-1)(q-1) を計算"] A3 --> A4["φ(N)と互いに素な e を選ぶ"] A3 --> A5["e × d ≡ 1 (mod φ(N)) となる d を計算"] A2 --> A6["公開鍵 (N, e)"] A4 --> A6 A5 --> A7["秘密鍵 d"] B1["2. 平文メッセージ M"] --> B2["C ≡ M^e (mod N) を計算"] A6 -.-> B2 B2 --> B3["暗号文 C を送信"] B3 --> C1["3. 受信した暗号文 C"] C1 --> C2["M ≡ C^d (mod N) を計算"] A7 -.-> C2 C2 --> C3["元の平文メッセージ M を取得"]

5.1 鍵生成（Key Generation）

受信者であるボブは、自分のための「公開鍵」と「秘密鍵」を生成します。

素数の選択: 2つの大きな素数 $p$ と $q$ をランダムに選びます。
法 $N$ の計算: $N = p \times q$ を計算します。この $N$ は公開されます。
$\phi(N)$ の計算: オイラー関数 $\phi(N) = (p - 1)(q - 1)$ を計算します。これはボブだけの秘密の数です。
公開鍵 $e$ の選択: $1 < e < \phi(N)$ であり、かつ $\phi(N)$ と互いに素である整数 $e$ を選びます。
秘密鍵 $d$ の計算: 次の条件を満たす整数 $d$ を見つけます。 $$ e \times d \equiv 1 \pmod{\phi(N)} $$ これはつまり、「$e \times d$ を $\phi(N)$ で割った余りが $1$ になるような数 $d$」です。

これで鍵の準備は完了です。

公開鍵: $(N, e)$ のペア。全世界に公開します。
秘密鍵: $d$。絶対に誰にも教えません。

5.2 暗号化（Encryption）

アリスはボブに秘密のメッセージ $M$ を送りたいとします。（$M$ は文字を数値化したもので、$0 \le M < N$ とします）。アリスはボブの公開鍵 $(N, e)$ を使って次のように計算します。

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

「メッセージ $M$ を $e$ 乗して、$N$ で割った余り $C$」を計算します。この $C$ が暗号文です。

5.3 復号（Decryption）

ボブは暗号文 $C$ を受け取ります。ボブは秘密鍵 $d$ を使って次のように計算します。

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

「暗号文 $C$ を $d$ 乗して、$N$ で割った余り」を計算すると、なんと元のメッセージ $M$ が復元されるのです！

6. なぜ復号で元に戻るのか？（数学的証明）

「$C$ を $d$ 乗するだけで、どうして元の $M$ に戻るの？」と疑問に思うかもしれません。ここで、先ほどの「オイラーの定理」が威力を発揮します。

復号の計算式 $C^d \pmod N$ に、暗号化の式 $C = M^e$ を代入してみましょう。

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

ここで、鍵生成のステップ 5 を思い出してください。ボブは $d$ を作るときに、$e \times d \equiv 1 \pmod{\phi(N)}$ となるように選びました。これは「$ed$ は $\phi(N)$ の倍数に $1$ を足した数である」ということを意味します。整数 $k$ を使って次のように書けます。

$$ ed = k \cdot \phi(N) + 1 $$

これを指数部分に代入し、指数法則を使って分解します。

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

ここで、メッセージ $M$ と $N$ が互いに素であると仮定すると、オイラーの定理より $M^{\phi(N)} \equiv 1 \pmod N$ となります。

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

したがって、見事に以下の式が成り立ちます。

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

アリスは $d$ を知らず、盗聴者も $d$ を知らないので、$C$ から $M$ を取り出せるのは $d$ を持っているボブだけなのです。

7. 具体例：小さな素数を使って手計算でRSAを体験してみよう

実際に小さな数字（素数）を使って、アリスからボブへ暗号通信をしてみましょう。

【ボブの鍵生成フェーズ】

2つの素数 $p=11$, $q=13$ を選びます。
$N = 11 \times 13 = 143$ を計算します。
$\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$ を計算します。
$\phi(N)=120$ と互いに素な公開鍵 $e$ を選びます。ここでは $e=7$ にします。
秘密鍵 $d$ を求めます。$7 \times d \equiv 1 \pmod{120}$ となる $d$ を探します。方程式 $7d = 120k + 1$ において、$k=6$ のとき $721$ となり、$721 \div 7 = 103$。したがって、$d = 103$ となります。

公開鍵：$(N=143, e=7)$
秘密鍵：$d=103$

【アリスの暗号化フェーズ】 メッセージ $M = 9$ を送りたいとします。式：$C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$。これを 143 で割ると $33447$ 余り $48$。暗号文 $C = 48$ となりました。

【ボブの復号フェーズ】 ボブは暗号文 $C = 48$ を受け取り、秘密鍵 $d = 103$ を使って復号します。式：$M \equiv 48^{103} \pmod{143}$ 計算機で (48 ** 103) % 143 を実行すると、見事に結果は「9」となります！元のメッセージを無事に受け取ることができました。

8. 秘密鍵 $d$ の求め方：拡張ユークリッドの互除法

手計算の例では勘で $k$ を探して $d=103$ を見つけましたが、数が何百桁にもなるとこの方法は不可能です。実際のプログラムでは**「拡張ユークリッドの互除法」**というアルゴリズムを使います。

$7d \equiv 1 \pmod{120}$ を解くということは、$7d + 120y = 1$ を満たす整数 $d, y$ を見つけることと同じです。ユークリッドの互除法を逆算していくことで、これを機械的に求めることができます。

$120 \div 7 = 17$ 余り $1$
これを変形すると、$1 = 120 - 17 \times 7$
つまり、$-17 \times 7 \equiv 1 \pmod{120}$

$-17$ は、法 $120$ の世界では $120 - 17 = 103$ と同じ意味になります。したがって、$d = 103$ が一瞬で求まるのです。この方法はどんなに巨大な数でも非常に高速に計算できます。

9. RSA暗号のもう一つの顔：デジタル署名

RSA暗号の素晴らしい点は、公開鍵と秘密鍵の役割を逆にすることで**「デジタル署名」**としても使えることです。

暗号化のときは「公開鍵で暗号化 $\Rightarrow$ 秘密鍵で復号」でしたが、デジタル署名では「秘密鍵で暗号化 $\Rightarrow$ 公開鍵で復号」という手順を踏みます。

flowchart TD A1["1. アリスが秘密鍵で署名作成"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["メッセージ M と署名 S を送信"] A3 --> B1["2. ボブが公開鍵で署名検証"] B1 --> B2["M' ≡ S^e (mod N) を計算"] B2 --> B3["M' と M が一致するか確認"]

アリスが自身の秘密鍵 $d$ を使ってメッセージを変換し（これが署名 $S$）、ボブに送ります。ボブはアリスの公開鍵 $e$ を使って検証計算をします。もし計算結果が元のメッセージと一致すれば、「アリスの秘密鍵でしか作れないデータである」ことと、「メッセージが途中で改ざんされていないこと」が同時に証明されるのです。

10. プログラムで実感するRSA暗号

手計算では大変な累乗計算も、Pythonを使えば非常に簡単に実装できます。以下はRSA暗号のコアとなるロジックを体験できるPythonコードです。

 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


def gcd(a, b):
 """最大公約数を求める"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """秘密鍵 d を求める（Python 3.8以降の組み込み機能を利用）"""
 return pow(e, -1, phi)

# 1. 鍵生成
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"公開鍵: (N={N}, e={e}), 秘密鍵: d={d}")

# 2. 暗号化
message = 9
ciphertext = pow(message, e, N)
print(f"暗号文: {ciphertext}")

# 3. 復号
decrypted_message = pow(ciphertext, d, N)
print(f"復号されたメッセージ: {decrypted_message}")

Pythonの pow(base, exp, mod) 関数は内部で「繰り返し二乗法」という高速アルゴリズムを使っているため、何百桁の数であっても一瞬で計算が終わります。

11. まとめと未来の暗号技術

高校数学の知識をベースに、RSA暗号の仕組みを解き明かしてきました。

素因数分解の困難性: $p \times q = N$ は簡単だが、$N$ から $p, q$ を見つけるのは非常に難しい。
合同式とオイラーの定理: $a^{\phi(N)} \equiv 1 \pmod N$ という法則により、「ある数で累乗すると元に戻る」魔法のトラップドアが完成する。
公開鍵と秘密鍵: 誰でも暗号化できるが、復号できるのは正当な受信者だけ。

現在使われているRSA暗号の $N$ は600桁以上あり、世界中のスーパーコンピュータを総動員しても素因数分解には宇宙の年齢以上の時間がかかります。しかし、近年研究が進んでいる「量子コンピュータ」が将来実用化されると、「ショアのアルゴリズム」によってこの素因数分解が一瞬で解かれてしまう可能性があります。そのため、現在は量子コンピュータでも解読できない「耐量子計算機暗号」の開発が世界中で急ピッチで進められています。

「役に立たない」と思われがちな高度な数学が、実は私たちの日常生活を根底から守っている。RSA暗号は、そんな数学の奥深さと美しさを教えてくれる最高の教材です。この記事を通して、暗号と数学の面白さを少しでも感じていただけたなら幸いです。

完全準同型暗号（FHE）とは？次世代セキュリティの要を解説

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

クラウドコンピューティングやAI技術が社会の基盤として定着する中、「データのプライバシー」と「データの利活用」のトレードオフは、最も重要な課題の一つとなっています。医療データ、金融情報、個人の生体情報など、機密性の高いデータをクラウド上でAIに解析させたいという需要は高まっていますが、セキュリティ上の懸念からデータの外部送信を躊躇する企業は少なくありません。

従来の暗号化技術（AESやRSAなど）は、ストレージに保存されているデータ（Data at Rest）やネットワーク上を流れるデータ（Data in Transit）を保護することには長けています。しかし、サーバー側でデータに対して検索や機械学習などの処理（計算）を行う際（Data in Use）には、一度暗号を復号して平文に戻す必要があります。もしこの復号されたタイミングでサーバーがハッキングされたり、内部の悪意ある管理者がデータを覗き見たりすれば、情報漏洩に直結します。

この「処理時の復号」という根本的な弱点を克服する夢の技術が、**完全準同型暗号（Fully Homomorphic Encryption: FHE）**です。FHEを利用すれば、データを暗号化したまま一切復号せずに計算処理を行い、その結果の暗号文だけをクライアントに返すことが可能になります。

本記事では、このFHEの概念から歴史、Craig Gentryによる画期的なブレイクスルー、数学的な基礎（Ring-LWEなど）、最大の課題である「ノイズ」とその解決策（ブートストラッピング）、そして最新の実装ライブラリに至るまで、次世代セキュリティの要であるFHEを徹底的に深く解説します。

1. 準同型暗号とは何か？基本的な概念

「準同型（Homomorphic）」とは代数学の用語であり、ある構造を持つ集合間で、演算の構造を保ったまま写像できる性質を指します。暗号理論における「準同型性」とは、平文空間での演算が、暗号文空間での演算に対応しているという性質です。

単純な数式で表すと、平文 $m_1$ と $m_2$ に対する暗号化関数を $E(\cdot)$ とし、復号関数を $D(\cdot)$ とします。平文上での演算（加算や乗算など）を $\circ$ 、暗号文上での演算を $\diamond$ としたとき、以下の関係が成り立ちます。

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

つまり、暗号文 $E(m_1)$ と $E(m_2)$ に対して何らかの演算 $\diamond$ を施した結果を復号すると、元の平文同士を演算 $\circ$ した結果と一致するということです。

クラウドコンピューティングにおけるデータフロー

FHEを用いたクラウド処理のアーキテクチャは、従来のものと全く異なります。以下の図は、FHEを活用したセキュアなデータ処理のフローを示しています。

サーバーは暗号化されたデータ $E(x)$ を受け取りますが、秘密鍵を持たないためデータの中身を知ることは絶対にできません。しかし、FHEの性質を利用することで、暗号文に対して関数 $f$（例えば機械学習の推論モデル）を適用し、$E(f(x))$ を生成することができます。クライアントはこれを受け取り、自身の秘密鍵で復号することで、目的の結果 $y = f(x)$ を手に入れます。

2. 準同型暗号の進化の歴史：PHE, SHE, FHE

準同型暗号は、一度に現在の「完全」な形になったわけではありません。実現できる演算の種類や回数によって、大きく3つの段階に分類されます。

Partially Homomorphic Encryption (PHE: 部分準同型暗号)

PHEは、加算か乗算のどちらか一方のみを無制限に行うことができる暗号方式です。実は、この性質を持つ暗号は古くから存在していました。

RSA暗号（乗算に対する準同型性） RSA暗号は意図せずして乗算の準同型性を持っていました。平文 $m_1, m_2$、公開鍵 $(e, N)$ とすると： $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ これらを掛け合わせると： $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ このように、暗号文同士の乗算が平文の乗算に対応します。
Paillier暗号（加算に対する準同型性） 1999年に考案されたPaillier暗号は、加算に対する準同型性を持ちます。電子投票（暗号化された票を集計し、最終結果だけを復号する）などで実用化されています。

Somewhat Homomorphic Encryption (SHE: 有界準同型暗号)

加算と乗算の両方を実行できますが、演算できる回数（回路の深さ）に制限がある方式です。後述する「ノイズ」の蓄積により、ある一定回数以上の乗算を行うと復号が不可能になってしまいます。2005年のBGN (Boneh-Goh-Nissim) 暗号などがこれに該当しますが、実用的な複雑な計算（ディープラーニングなど）を行うには限界がありました。

Fully Homomorphic Encryption (FHE: 完全準同型暗号)

加算と乗算の両方を、回数無制限で実行できる暗号方式です。情報理論におけるチューリング完全性と同様に、加算（XORに相当）と乗算（ANDに相当）を無限に組み合わせることができれば、原理上いかなる計算可能な関数・アルゴリズムも暗号化されたまま実行できることを意味します。

FHEは長らく「暗号界の聖杯」と呼ばれ、実現不可能ではないかとも言われていました。しかし、2009年に当時スタンフォード大学の博士課程にいた Craig Gentry が、理想格子（Ideal Lattices）を用いた最初のFHEスキームを提案し、世界に衝撃を与えました。

3. FHEの数学的基盤：LWE問題とRing-LWE

現在の主流となっているFHEスキームの多くは、耐量子計算機暗号（Post-Quantum Cryptography）としても知られる「格子暗号（Lattice-based Cryptography）」の数学的難問である LWE (Learning With Errors) 問題に基づいています。

LWE問題の直感的な理解

連立一次方程式を解くことは、ガウスの消去法などを用いれば簡単です。

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

しかし、この方程式の結果に、ごく僅かな「ランダムな誤差（ノイズ）」$e$ を加えるとどうなるでしょうか。

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

この誤差 $e$ が加わるだけで、秘密の変数ベクトル $\vec{s}$ を見つけ出す問題は、現在のスーパーコンピュータや量子コンピュータを用いても解読が困難なNP困難な問題へと変貌します。これがLWE問題です。

Ring-LWE問題（RLWE）

標準のLWE問題は行列演算を含むため、鍵のサイズが非常に大きく（ギガバイト単位になることも）、計算効率も悪いという問題がありました。これを解決するために導入されたのが、多項式環上の演算を用いる Ring-LWE (RLWE) 問題です。

RLWEでは、要素が多項式環 $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ に属します（ここで $N$ は2の冪乗、$q$ は法となる素数）。秘密鍵を多項式 $s(x)$ とし、ランダムな多項式 $a(x)$、小さなノイズ多項式 $e(x)$ とすると、公開鍵は以下のペアになります。

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

暗号化の際には、この多項式の性質を利用して平文 $m(x)$ をエンコードし、暗号文を生成します。

4. 最大の障壁「ノイズ」とGentryのブートストラッピング

FHEの理解において最も重要な概念が**「ノイズの管理」**です。

LWE/RLWEベースの暗号では、安全性を担保するために意図的に小さな「ノイズ（誤差）」を含めています。平文 $m$ の暗号文 $c$ を復号するプロセスは、大雑把に言えば次のような数式で表されます。

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

復号時には、この noise を丸め処理などで取り除くことで正しい平文 $m$ を得ます。しかし、暗号文同士で準同型演算（特に乗算）を行うと、このノイズが劇的に増幅してしまいます。

準同型加算: ノイズは足し算的に増加します（$e_1 + e_2$）。これは比較的緩やかな増加です。
準同型加算による準同型性の数式表現: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
準同型乗算: ノイズは掛け算的に爆発します（$e_1 \times e_2$ などを含むため）。数回乗算するだけでノイズがしきい値 $q/2$ を超えてしまい、正しい丸め処理ができず復号に失敗します。
準同型乗算による準同型性の数式表現: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

これが、長い間FHEが実現できず、SHE（回数制限付き）に留まっていた理由です。

ブートストラッピング（Bootstrapping）の魔法

Craig Gentryの天才的な貢献は、**「ブートストラッピング」**と呼ばれるノイズ削減の手法を発明したことです。これは暗号学におけるパラダイムシフトでした。

直感的には「暗号文がノイズまみれになって壊れる前に、暗号化されたままの状態で『復号』して綺麗にし、新しい暗号文に入れ直す」という操作です。

ノイズが大きくなった暗号文 $C_{noisy}$ があるとします。
クライアントは、秘密鍵 $sk$ を「公開鍵で暗号化したもの」$E_{pk}(sk)$（これをブートストラッピングキーと呼ぶ）をあらかじめサーバーに渡しておきます。
サーバーは、$C_{noisy}$ に対して、準同型的に**復号回路（Decryption Circuit）**を実行します。
具体的には、$E_{pk}(C_{noisy})$ に対して $E_{pk}(sk)$ を用いて「暗号化された空間内での復号」を行います。
この復号回路自体も準同型演算であるため新たなノイズを生みますが、出力される新しい暗号文 $C_{fresh}$ のノイズは、一定の「固定レベル」にリセットされます。

graph LR A["高ノイズ暗号文 C_noisy"] --> B["準同型復号回路 (Eval_Dec)"] C["暗号化された秘密鍵 E(sk)"] --> B B --> D["低ノイズ暗号文 C_fresh"] style B fill:#ffeeba,stroke:#ffc107

このブートストラッピングを計算の途中で定期的に実行することで、理論上は無限の深さの回路を計算可能（FHEの達成）にしました。しかし、初期のGentryの方式は、このブートストラッピング処理に1回あたり数十分から数時間かかるという、絶望的なほど計算コストが高いものでした。

5. FHEの世代と主要なスキームの進化

FHEの実用化に向けて、世界中の暗号学者が競うようにアルゴリズムを改良してきました。現在、FHEは主に4つの世代・ファミリーに分類されます。

第2世代：整数の正確な演算 (BGV, BFV)

2011〜2012年にかけて登場した BGV (Brakerski-Gentry-Vaikuntanathan) と BFV (Brakerski/Fan-Vercauteren) スキームです。これらはRLWEを基盤としており、整数のモジュラ演算（正確な計算）に適しています。 SIMD (Single Instruction, Multiple Data) のようなバッチング（Batching）技術をサポートしており、1つの巨大な多項式の暗号文の中に、何千ものデータスロットを詰め込んで一度に並列計算できるのが特徴です。

第3世代：ブートストラッピングの高速化 (GSW, FHEW, TFHE)

2013年の GSW (Gentry-Sahai-Waters) スキームは、FHEの構造をよりシンプルにしました。そしてこれを発展させたのが、現在の主流の一つである TFHE (Fast Fully Homomorphic Encryption over the Torus) です。 TFHEの特徴は、ブートストラッピングが非常に高速（ミリ秒単位）であることです。ゲート単位（AND, XORなどの論理回路）での演算に強く、暗号文のサイズも比較的小さいため、任意の論理回路を高速に評価するのに適しています。

第4世代：近似計算と機械学習への特化 (CKKS)

2017年にCheonらによって提案された CKKS (Cheon-Kim-Kim-Song) スキームは、現在のAI・機械学習のプライバシー保護における決定版と言える技術です。これまでのFHEが「正確な整数計算」にこだわっていたのに対し、CKKSは**「浮動小数点数の近似計算」**を暗号化されたままサポートします。ニューラルネットワークの学習や推論など、小さな誤差が許容される実数計算において、圧倒的なパフォーマンスを発揮します。

以下の表に、目的別のスキームの選び方をまとめます。

スキーム名	得意なデータ型	推奨されるユースケース	特徴
BFV / BGV	整数 (Integer)	正確な統計計算、金融データ集計、DB検索	SIMDバッチングによる高スループット
CKKS	実数 (Real/Complex)	機械学習 (DNN, ロジスティック回帰)、信号処理	近似計算による高速化、再スケーリング
TFHE	ブール値 (Boolean)	任意の論理回路、文字列検索、非線形関数の評価	超高速ブートストラッピング（ミリ秒台）

6. 実践：FHEライブラリと概念的なコード

現在では、暗号学の深い知識がなくてもFHEを利用できるオープンソースのライブラリが多数提供されています。

Microsoft SEAL (Simple Encrypted Arithmetic Library): BFV, BGV, CKKSをサポートするC++ライブラリ。業界標準の一つ。Pythonバインディングである TenSEAL がAIエンジニアの間で人気です。
Zama (Concrete): TFHEをベースにしたフレームワーク。Rust/Pythonで記述でき、既存のPyTorchモデルをコンパイルしてFHE上で動かす機能（Concrete ML）を提供しています。
OpenFHE: PALISADEの後継で、すべての主要なスキームをサポートする包括的なC++ライブラリ。

Python (TenSEAL) を用いたFHEプログラミングの例

ここでは、CKKSスキームを用いて、暗号化されたまま実数ベクトルを足し合わせ、掛け合わせる概念的なPythonコードの例を示します。

 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


import tenseal as ts

# 1. コンテキストのセットアップ (鍵生成を含む)
# CKKSスキームを使用し、多項式の次数を8192に設定
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # 実数のスケーリングファクタ

# 2. クライアント側：データの暗号化
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# 平文ベクトルを暗号文に変換 (本来はクライアント側で実行)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. サーバー側：暗号化されたままの演算 (Data in Useの保護)
# サーバーは平文を知らないが、加算と乗算を実行できる
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. クライアント側：結果の復号
# 秘密鍵を持つクライアントだけが結果を見ることができる
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"復号された加算結果: {res_add}")
# 出力例: [3.5000001, 5.5000001, 7.5000002] (近似計算のため微小な誤差が含まれる)

print(f"復号された乗算結果: {res_mul}")
# 出力例: [3.0000002, 7.5000005, 14.0000003]

上記のコードからわかるように、enc_v1 + enc_v2 のように通常のPythonの演算子をオーバーロードして直感的に暗号文同士の計算を記述することができます。サーバー側では、ベクトルの中身を知らずにベクトル演算を完了させています。

7. FHEの課題：パフォーマンスとハードウェアアクセラレーション

FHEは理論的に完璧なセキュリティを提供しますが、実用化における最大の課題は**「パフォーマンスのオーバーヘッド」**です。

計算のオーバーヘッド: 平文での計算に比べ、暗号文での計算はCPU上で数千倍〜数万倍遅くなります。多項式の乗算やブートストラッピングには膨大なFFT（高速フーリエ変換）やNTT（数論変換）の計算が必要です。
データサイズの膨張 (Ciphertext Expansion): 数バイトの平文が、暗号化されると数メガバイトになることがあります。これはメモリ帯域やネットワーク帯域を強く圧迫します。

ハードウェアによる解決へのアプローチ

このオーバーヘッドを克服するため、世界中でFHE専用のハードウェアアクセラレータ（ASIC, FPGA, GPU対応）の開発が進められています。

GPUアクセラレーション: NVIDIAなどの強力なGPUを用いて、NTT演算やブートストラッピングを並列化する取り組みが進んでおり、ソフトウェア実装に対して数十倍の高速化が報告されています（例：100x.ai, ZamaのTFHE-rs CUDA backend）。
DARPA DPRIVE プロジェクト: 米国防高等研究計画局（DARPA）は、FHEの計算速度を平文処理の実行速度と同等レベル（オーバーヘッド10倍以内）に引き上げるための専用ハードウェア開発プロジェクト「DPRIVE (Data Protection in Virtual Environments)」を推進しており、IntelやMicrosoft、Intellectual Venturesなどが参加しています。
FPU (FHE Processing Unit) の登場: CornamiやOptalysysといったスタートアップが、光コンピューティングや特殊なシリコンアーキテクチャを用いたFHE専用チップの開発に乗り出しています。

近い将来、AIにおけるNPU（Neural Processing Unit）のように、サーバーやクラウドインフラに「FPU」が標準搭載される時代が来るかもしれません。

8. 期待されるユースケース

FHEが実用的な速度に到達しつつある今、以下のような分野での破壊的イノベーションが期待されています。

医療・ゲノム解析のプライバシー保護: 複数の病院が持つ患者のカルテデータやDNAデータを、FHEで暗号化したままクラウドのAIに学習させることで、プライバシー法（HIPAAやGDPR）に違反することなく、高精度な癌診断モデルや新薬開発を行うことができます。
金融機関の不正検知・マネーロンダリング対策 (AML): 競合する銀行同士が、顧客の口座情報や取引履歴を明かすことなく、暗号化された状態で互いのデータを照合し、巨大な不正送金ネットワークを検知するクロスバンク分析が可能になります。
セキュアなAI推論API (MaaS: Model as a Service): ユーザーは自身の音声や顔画像、プロンプトを暗号化してAIサービス（ChatGPTのようなLLMなど）に送信します。AIプロバイダーはユーザーの入力を一切知ることなく回答を生成し、暗号文として返します。これにより、「AIに個人情報を学習される・盗み見られる」という懸念が完全に払拭されます。

9. 結論：暗号の未来は「見えない計算」へ

1970年代に公開鍵暗号（RSA）が発明されてインターネット上の安全な通信（HTTPSなど）が可能になったように、Craig GentryによるFHEの発明は、暗号の歴史における最も重要なマイルストーンの一つです。

現在、完全準同型暗号（FHE）は研究室の理論から飛び出し、Microsoft、IBM、Intel、Google、そして多くのスタートアップが実用化に向けてしのぎを削る段階に入っています。計算コストやデータサイズの課題は依然として存在しますが、アルゴリズムの洗練とハードウェアアクセラレータの進化により、ムーアの法則を超えるペースで性能向上が続いています。

数年後、「データを暗号化したまま計算する」ことは特別なことではなく、クラウドサービスにおける標準的なデータ保護のベストプラクティスとなるでしょう。FHEは、データ駆動型社会における究極のプライバシーとデータ利活用の両立を実現する、次世代セキュリティの要なのです。

楕円曲線暗号（ECC）の数学的基礎とC++での実装

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

楕円曲線暗号（ECC）の数学的基礎とC++での実装

現代の暗号技術において、**楕円曲線暗号（Elliptic Curve Cryptography: ECC）**は極めて重要な役割を果たしています。私たちの日常的なインターネット通信（HTTPS/TLS）から、スマートフォンのセキュアエンクレーブ、SSHによるサーバー認証、FIDOなどのパスワードレス認証、さらにはビットコインやイーサリアムなどの暗号資産に至るまで、現代のデジタル社会の信頼基盤はECCによって支えられていると言っても過言ではありません。

本記事では、この楕円曲線暗号がいかにして機能しているのか、その背後にある美しくも難解な数学的理論（有限体上の代数幾何学）から出発し、実際のC++を用いた実装方法、さらにはサイドチャネル攻撃（タイミング攻撃）を防ぐためのセキュアなコーディング手法まで、圧倒的なボリュームで徹底的に解説します。

1. なぜ楕円曲線暗号なのか？（RSAとの比較）

公開鍵暗号方式の代名詞といえば、長らくRSA暗号でした。RSA暗号は「巨大な合成数の素因数分解の困難性」を安全性の根拠としています。しかし、コンピューターの計算能力の向上に伴い、安全性を維持するためにはRSAの鍵長（モジュラスのビット数）を継続的に長くする必要が生じました。現在では、最低でも2048ビット、より安全を期すなら3072ビットや4096ビットの鍵長が推奨されています。

これに対して、楕円曲線暗号（ECC）は**「楕円曲線上の離散対数問題（ECDLP）」**という別の数学的困難性を安全性の根拠としています。ECDLPを解くための効率的なアルゴリズム（準指数関数時間アルゴリズムなど）は現在に至るまで発見されておらず、既知の最も効率的な攻撃手法であっても指数関数的な時間を要します。

この性質により、ECCは非常に短い鍵長でRSAと同等のセキュリティ強度を実現できるという決定的な利点を持ちます。

セキュリティ強度（ビット）	RSA暗号の鍵長（ビット）	楕円曲線暗号の鍵長（ビット）	鍵長の比率
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

上記の表が示すように、128ビットのセキュリティ強度（現在標準的な強度）を得るために、RSAでは3072ビットの鍵が必要ですが、ECCであればわずか256ビットで済みます。これにより、計算量の削減、メモリ使用量の低減、ネットワーク帯域の節約が可能となり、特にリソースが限られたIoTデバイスやスマートカード環境において圧倒的な優位性を誇ります。

2. 数学的準備：群論と有限体の世界

楕円曲線暗号を真に理解するためには、抽象代数学（群論および体論）の基本的な概念を押さえておく必要があります。ここでは、ECCを構成するための前提知識を簡潔にまとめます。

2.1. 群（Group）とアーベル群

**群（Group）**とは、ある集合 $G$ と、その集合上の二項演算（ここでは加法 $+$ とします）の組 $(G, +)$ であり、以下の4つの公理を満たすものです。

閉性（Closure）: 任意の $a, b \in G$ について、$a + b \in G$ である。
結合法則（Associativity）: 任意の $a, b, c \in G$ について、$(a + b) + c = a + (b + c)$ が成り立つ。
単位元の存在（Identity element）: 任意の $a \in G$ について、$a + e = e + a = a$ となる要素 $e \in G$ が存在する。加法群の場合、この単位元を通常 $0$ または $\mathcal{O}$ と表記します。
逆元の存在（Inverse element）: 任意の $a \in G$ に対して、$a + b = b + a = e$ となる要素 $b \in G$ が存在する。この $b$ を $-a$ と表記します。

さらに、演算の順序を入れ替えても結果が変わらない、すなわち以下の条件を満たす群を**アーベル群（可換群）**と呼びます。

交換法則（Commutativity）: 任意の $a, b \in G$ について、$a + b = b + a$ が成り立つ。

楕円曲線上の点の集合は、特定の加法ルールを定義することで、このアーベル群を構成します。

2.2. 有限体（Finite Field）

暗号理論においては、実数や複素数のような連続的で無限の要素を持つ体ではなく、要素の数が有限である**有限体（Finite Field）**またはガロア体（Galois Field）を使用します。

最も基本的な有限体は、素数 $p$ を用いた素体 $\mathbb{F}_p$ です。これは、$\{0, 1, 2, \dots, p-1\}$ の整数の集合に、モジュロ $p$ （$p$ で割った余り）での四則演算（加算、減算、乗算、除算）を定義したものです。

加算: $(a + b) \pmod p$
減算: $(a - b) \pmod p$
乗算: $(a \times b) \pmod p$
除算: $a \times b^{-1} \pmod p$ （ここで $b^{-1}$ はモジュロ $p$ における $b$ の乗法逆元）

**乗法逆元（Modular Multiplicative Inverse）**の計算は暗号実装において非常に重要です。$b \times b^{-1} \equiv 1 \pmod p$ を満たす $b^{-1}$ を求めるには、主に以下の2つのアルゴリズムが用いられます。

拡張ユークリッドの互除法（Extended Euclidean Algorithm）: 高速ですが、実装によっては処理時間が入力値に依存するためタイミング攻撃のリスクがあります。
フェルマーの小定理（Fermat’s Little Theorem）: $p$ が素数で $b \neq 0$ のとき、$b^{p-1} \equiv 1 \pmod p$ が成り立ちます。両辺を $b$ で割ると、$b^{p-2} \equiv b^{-1} \pmod p$ となります。つまり、$b$ の $p-2$ 乗を計算することで逆元が求まります。べき乗演算は定数時間で実装しやすいため、暗号実装ではこちらが好まれます。

3. 楕円曲線の方程式と幾何学

3.1. ワイエルシュトラスの標準形

**楕円曲線（Elliptic Curve）は、一般に以下のワイエルシュトラスの標準形（Weierstrass normal form）**と呼ばれる方程式で定義される平面曲線です。

$$ y^2 = x^3 + ax + b $$

ここで、$a$ と $b$ は定数であり、曲線が特異点（自己交差や尖点）を持たない（滑らかな曲線である）ための条件として、以下の判別式（Discriminant） $\Delta$ がゼロでないことが求められます。

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

特異点を持つ曲線は暗号学的な安全性を損なうため、必ずこの条件を満たす係数 $a, b$ が選ばれます。

3.2. 無限遠点（Point at Infinity）

楕円曲線を数学的に完全な群にするために、平面上の点に加えて**「無限遠点（Point at Infinity）」**と呼ばれる仮想的な点を導入します。これを $\mathcal{O}$ （オー）と表記します。

無限遠点 $\mathcal{O}$ は、すべての垂直線が無限の彼方で交わる点として定義されます。群論において、この無限遠点 $\mathcal{O}$ は加法における単位元（ゼロ）として機能します。

すなわち、曲線上の任意の点 $P$ に対して、以下が成り立ちます。

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

また、点 $P = (x, y)$ の逆元 $-P$ は、x軸に対して対称な点 $(x, -y)$ と定義されます。したがって：

$$ P + (-P) = \mathcal{O} $$

となります。

4. 楕円曲線上の群演算（点の加算と2倍算）

楕円曲線暗号の根幹をなすのが、曲線上の点同士の**「加算（Addition）」**という演算です。これは通常の整数の足し算とは異なり、幾何学的な操作に基づいて定義されています。

4.1. 幾何学的な加算（Tangent and Chord Method）

曲線上の異なる2点 $P$ と $Q$ を足して新しい点 $R$ ($R = P + Q$) を求める手順は以下の通りです。

点 $P$ と点 $Q$ を通る直線（弦）を引きます。
この直線は、楕円曲線と必ずもう一つの点（これを $-R$ とします）で交わります。（※代数幾何学の定理によります）
交点 $-R$ をx軸に対して対称に折り返した点（y座標の符号を反転させた点）が、求める点 $R$ となります。

graph TD Step1["P(x1, y1) と Q(x2, y2) を結ぶ直線を引く"] --> Step2["曲線との第3の交点 -R を見つける"] Step2 --> Step3["-R をx軸で折り返し、R(x3, y3) を得る"] Step3 -.-> Result["これが R = P + Q"]

4.2. 点の2倍算（Point Doubling）

点 $P$ に同じ点 $P$ を足す場合（$P + P = 2P$）、2点を通る直線を引くことができません。この場合は、**点 $P$ における曲線の接線（Tangent）**を引きます。

点 $P$ における曲線の接線を引きます。
この接線は曲線ともう一つの点 $-R$ で交わります。
交点をx軸で対称に折り返した点が、求める点 $R = 2P$ となります。

4.3. 代数的な計算公式

幾何学的な操作を、コンピューターで計算できるように代数的な公式に落とし込みます。演算はすべて**有限体 $\mathbb{F}_p$ 上（モジュロ $p$）**で行われます。

点 $P = (x_1, y_1)$、点 $Q = (x_2, y_2)$ とします。また、計算結果の点を $R = P + Q = (x_3, y_3)$ とします。

直線の傾きを $\lambda$（ラムダ）とします。

【ケース1： $P \neq Q$ の場合（点の加算）】 傾き $\lambda$ は、2点間の変化の割合です。

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

この $\lambda$ を用いて、$x_3, y_3$ は次のように求まります。

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

【ケース2： $P = Q$ の場合（点の2倍算）】 傾き $\lambda$ は、微分によって求められる接線の傾きになります。（$y^2 = x^3 + ax + b$ を暗黙に微分します）

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

したがって、

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

$x_3, y_3$ の式は加算と同じ形ですが、$x_2 = x_1$ であるため以下のようになります。

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] これらの公式には $(x_2 - x_1)^{-1}$ や $(2y_1)^{-1}$ といった**除算（モジュロ逆元の計算）が含まれています。モジュロ逆元の計算は計算コストが非常に高いため、実際の実装では除算を遅延させる「ヤコビ座標系（Jacobian Coordinates）」**などの射影座標系が一般的に用いられます。

5. スカラー倍算と楕円曲線離散対数問題（ECDLP）

楕円曲線暗号において、最も計算量が多く、かつセキュリティの中核をなす演算が**スカラー倍算（Scalar Multiplication）**です。

5.1. スカラー倍算とは

ある点 $P$ を $k$ 回足し合わせる操作をスカラー倍算と呼び、$kP$ と表記します。

$$ kP = \underbrace{P + P + \dots + P}_{k\text{回}} $$

ここで、$k$ は非常に大きな整数（例えば256ビットの整数）です。

5.2. 楕円曲線離散対数問題（ECDLP）

楕円曲線暗号の安全性は、以下の問題の困難性に依存しています。

楕円曲線離散対数問題 (Elliptic Curve Discrete Logarithm Problem: ECDLP) 既知の点 $P$（ベースポイント）と、計算結果の点 $Q$ が与えられたとき、$Q = kP$ を満たすスカラー $k$ を求めよ。

$k$ と $P$ から $Q$ を計算する（順方向）のは後述のアルゴリズムを用いれば簡単（多項式時間）ですが、$P$ と $Q$ から $k$ を逆算する（逆方向）ことは、総当たり的な探索以外に効率的な解法がなく、事実上不可能です（一方向性関数）。暗号プロトコルにおいては、**$k$ が「秘密鍵」、$Q$ が「公開鍵」**に対応します。

5.3. Double-and-Add アルゴリズム

$k$ が巨大な数（例：$2^{256}$）の場合、$P$ を愚直に $k$ 回足し合わせることは宇宙の寿命が尽きても終わりません。そこで、高速にスカラー倍算を行うために**Double-and-Add法（バイナリ法）**が用いられます。

これは、整数のべき乗を高速に計算する「繰り返し二乗法」の楕円曲線版です。スカラー $k$ を2進数表現し、上位ビットから順に処理します。

結果を保持する点 $R$ を $\mathcal{O}$ で初期化する。
$k$ の最上位ビットから最下位ビットまで以下を繰り返す：
- $R$ を2倍する（Point Doubling: $R = 2R$）
- もし現在のビットが 1 なら、$R$ に $P$ を足す（Point Addition: $R = R + P$）

このアルゴリズムにより、計算量は $O(k)$ から $O(\log_2 k)$ に劇的に削減され、現実的な時間（ミリ秒単位）で計算が可能になります。

6. 楕円曲線ディフィー・ヘルマン（ECDH）鍵共有

ここでは、ECCの最も代表的な応用例であるECDH（Elliptic Curve Diffie-Hellman）鍵共有プロトコルの仕組みを解説します。ECDHは、盗聴可能な通信路上で、アリスとボブが安全に共通の秘密鍵（セッションキー）を生成・共有するための仕組みです（TLSハンドシェイクの中核です）。

【前提パラメータ（ドメインパラメータ）】 両者はあらかじめ、使用する楕円曲線 $E$、素数 $p$、およびベースポイント $G$ を共有しています。（例としてNIST P-256やsecp256k1など）

sequenceDiagram participant Alice as "Alice (アリス)" participant Bob as "Bob (ボブ)" Note over Alice,Bob: "公開パラメータ: 曲線 E, ベースポイント G, 素数 p" Alice->>Alice: "秘密鍵 d_A (ランダムな整数) を生成" Alice->>Alice: "公開鍵 Q_A = d_A * G を計算" Bob->>Bob: "秘密鍵 d_B (ランダムな整数) を生成" Bob->>Bob: "公開鍵 Q_B = d_B * G を計算" Alice->>Bob: "公開鍵 Q_A を送信 (平文)" Bob->>Alice: "公開鍵 Q_B を送信 (平文)" Alice->>Alice: "共有シークレット S = d_A * Q_B を計算" Bob->>Bob: "共有シークレット S = d_B * Q_A を計算" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "両者の計算結果 S は完全に一致する！"

盗聴者（イヴ）は通信経路上を流れる $G$、$Q_A$、$Q_B$ を傍受できますが、ECDLPの困難性により、$Q_A = d_A \cdot G$ からアリスの秘密鍵 $d_A$ を割り出すことはできません。また、$Q_A$ と $Q_B$ を掛け合わせても共有鍵 $S$ にはならないため、盗聴者は $S$ を計算することができません。

7. 実装の落とし穴：サイドチャネル攻撃と対策

理論的に完璧な暗号アルゴリズムであっても、それをプログラムとして実装する過程で脆弱性が生まれ得ます。それが**「サイドチャネル攻撃（Side-Channel Attack）」**です。

7.1. タイミング攻撃（Timing Attack）

前述の Double-and-Add アルゴリズムを振り返ってみましょう。

1
2
3
4
5
6
7
8


// 脆弱な Double-and-Add の疑似コード
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // 常に実行される
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // ビットが1のときだけ実行される！
 }
}

この実装には致命的な欠陥があります。ビットが 1 のときは Point Addition が実行されるため、ビットが 0 のときよりも計算時間がわずかに長くなります。また、プロセッサの分岐予測やキャッシュメモリの挙動も変化します。攻撃者がこの計算時間（あるいは消費電力）の微小な差異を何千回も統計的に観測することで、秘密鍵 $k$ のビット列を1ビットずつ完全に復元されてしまいます。これがタイミング攻撃です。

7.2. Constant-Time 実装：Montgomery Ladder

タイミング攻撃を防ぐためには、**秘密鍵のビット値にかかわらず、実行される命令のシーケンスと計算時間が常に一定（Constant-Time）**であるアルゴリズムを採用する必要があります。

その代表例が**Montgomery Ladder（モンゴメリのラダー）**です。

graph TD Start["初期化: R0 = O, R1 = P"] --> LoopStart["各ビット i について (最上位から)"] LoopStart --> Cond{"k_i の値は？"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["次のビットへ"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"全ビット完了"| End["終了: R0 が結果 (kP)"]

Montgomery Ladderの美しい点は、ビットが 0 であっても 1 であっても、**「常に1回のPoint Additionと1回のPoint Doubling」**が実行されることです。これにより、計算時間のデータ依存性が完全に排除されます。

ただし、分岐（if (k_i == 0)）自体が存在すると、コンパイラの最適化やCPUの分岐予測によって実行時間が変動するリスクが残ります。そのため、実際のConstant-Time実装では、条件分岐（if文）を排除し、**ビット演算を用いた条件付きスワップ（Conditional Swap）**を利用します。

8. C++による楕円曲線暗号の実装

ここからは、理論をC++のコードに落とし込んでいきます。実用的な暗号ライブラリ（OpenSSLやlibsodiumなど）は高度なアセンブリ最適化やヤコビ座標系を使用していますが、ここでは数学的理解を深めるために、アフィン座標系を用いたわかりやすいConstant-Time実装の骨組みを示します。

巨大な整数の演算には boost::multiprecision::cpp_int を用いると仮定します。

8.1. モジュロ演算と逆元

まず、有限体上の演算ヘルパー関数を定義します。フェルマーの小定理による逆元計算を実装します。

 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


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// 例として secp256k1 の素数 p とパラメータ
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// 正の剰余を返すモジュロ演算
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// べき乗剰余計算 (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// フェルマーの小定理を用いたモジュロ逆元
cpp_int modInverse(cpp_int n, cpp_int m) {
 // mが素数である前提: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. 点の表現と群演算（加算・2倍算）

無限遠点をフラグで管理する Point 構造体と、加算の公式を実装します。

 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


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // 無限遠点の生成
 Point() : x(0), y(0), isInfinity(true) {}

 // 通常の点の生成
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// 楕円曲線上の点の加算 (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = 無限遠点
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (P = Q の場合)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (P != Q の場合)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Constant-Time Conditional Swap の実装

秘密鍵のビット値に基づいて変数の中身を入れ替える際、if 文を使わずにビット演算（マスク）のみで入れ替えを行います。これにより実行経路が完全に一定になります。

[!TIP] 実際の実装では、cpp_int のような動的確保される多倍長整数クラスは Constant-Time 処理には適していません。メモリ割り当てや配列サイズの変動によってタイミング情報が漏洩するためです。実用ライブラリでは、固定長（例えば uint64_t × 4要素の配列）で表現し、ビット単位でのマスク処理を実装します。以下は概念的な例です。

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


// 概念的な Constant-Time Swap (固定長整数の場合を想定)
// bit が 1 なら P1 と P2 を交換し、0 なら交換しない
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit は 0 または 1。マスクは bit=1 なら全ビット1(0xFF..)、0なら全ビット0。
 // (ここでは説明のため、固定長の BigInt クラスの各ワードを w と仮定)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // y座標や isInfinity フラグも同様に処理
 }
 */

 // ※ boost::multiprecision での完全な定数時間スワップは困難ですが、
 // ここではロジックの理解のために分岐によるシミュレートにとどめます。
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Montgomery Ladder によるスカラー倍算

前述の pointAdd と cswap を組み合わせて、セキュアなスカラー倍算を実装します。

 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


// スカラー倍算 k * P (Montgomery Ladder 方式)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // 無限遠点
 Point R1 = P;

 // k のビット長を取得 (secp256k1 なら 256 ビット)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // iビット目の値を取得 (0 または 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // bit == 1 なら R0 と R1 をスワップ
 cswap(R0, R1, bit);

 // 常に同じ演算を実行 (Point Addition と Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // bit == 1 だった場合、状態を元に戻すために再度スワップ
 cswap(R0, R1, bit);
 }

 return R0;
}

この実装ロジックにより、スカラー $k$ の各ビットが 0 であっても 1 であっても、各ループイテレーション内で実行される演算（cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap）は全く同じフローとなり、タイミングやキャッシュアクセスパターンの差異を通じた秘密情報の漏洩を強力に防ぐことができます。

9. まとめ

楕円曲線暗号（ECC）は、初見では「なぜ直線を引いて交点を折り返すという幾何学的な操作が暗号になるのか？」と不思議に思えるかもしれません。しかし、有限体という離散的な世界にマッピングすることで、見事な一方向性関数（離散対数問題）を構築できるという、数学と暗号学の奇跡的な融合の産物です。

本記事では以下の重要なポイントを解説しました。

RSAに対する優位性: 非常に短い鍵長で強力なセキュリティを提供し、現代のモバイル・IoT時代に最適であること。
群論と有限体の基礎: ECCの土台となる数学的構造。
加算と2倍算の公式: ワイエルシュトラス方程式を用いた代数的な群演算の実装方法。
サイドチャネル攻撃の脅威: 秘密鍵のビットに依存した条件分岐が致命的な脆弱性を生むこと。
Constant-Time 実装: Montgomery Ladder と Conditional Swap を用いて、ハードウェアレベルの挙動を均一化し攻撃を防ぐC++コーディング技法。

実際にプロダクション環境で動作する暗号ライブラリを自作することは、セキュリティ上のリスクが極めて高いため非推奨（“Don’t roll your own crypto”）とされています。しかし、その内部で動いているアルゴリズムと数学的背景を深く理解することは、よりセキュアでパフォーマンスの高いシステムを設計・運用するエンジニアにとって、かけがえのない強力な武器となるはずです。

次回の記事では、この楕円曲線を用いたデジタル署名アルゴリズムである ECDSA (Elliptic Curve Digital Signature Algorithm) のメカニズムや、ビットコインで採用されている Schnorr署名 についてさらに深く掘り下げていきたいと思います。

GNFS（一般数体篩法）を超えるアルゴリズムは存在するのか？

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

1. はじめに：素因数分解と現代暗号の根幹

現代社会におけるインターネット通信の安全性は、公開鍵暗号であるRSA暗号の安全性に大きく依存しています。そしてRSA暗号の安全性は「巨大な合成数の素因数分解の困難さ」という数学的仮定に基づいています。もし、極めて効率的な素因数分解アルゴリズムが発見されれば、世界中の通信インフラは根底から崩れ去ることになります。

現在、古典コンピュータを用いた巨大整数の素因数分解において、最も高速かつ最強のアルゴリズムとして君臨しているのが**一般数体篩法（GNFS: General Number Field Sieve）**です。GNFSは、1980年代後半に提唱された特殊数体篩法（SNFS）を拡張する形で誕生し、今日に至るまでRSA-768やRSA-250といった巨大な合成数の素因数分解記録を打ち立ててきました。

しかし、暗号学者や数学者たちは常に次のような疑問を抱いています。「GNFSを超える古典的アルゴリズムは存在するのか？」「古典コンピュータの限界はどこにあるのか？」そして、「量子コンピュータはどのようにこの状況を打破するのか？」

本記事では、GNFSの背後にある深淵なる数学的構造を徹底的に解剖し、多項式選択、篩処理、ブロック・ヴィーデマン法による線形代数ステップなどの詳細な技術的分析を行います。さらに、Coppersmithの改良などによるGNFSの拡張手法について考察し、古典的な準指数関数時間（Sub-exponential time）アルゴリズムと量子的多項式時間アルゴリズムの決定的な違いを数理的な観点から比較・解説します。

2. 漸近的計算量とL記法（L-notation）

素因数分解アルゴリズムの計算量を評価する際、標準的な多項式時間表記（$O(n^k)$など）ではなく、入力 $n$ の桁数に対する準指数関数時間を表現するために**L記法（L-notation）**が用いられます。L記法は次のように定義されます。

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

ここで、$n$ は素因数分解の対象となる整数、$\ln n$ は自然対数であり $n$ のビット長に比例します。

$\alpha = 0$ の場合：$L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$ となり、ビット長に対する**多項式時間（Polynomial time）**を表します。
$\alpha = 1$ の場合：$L_n[1, c] = \exp(c \ln n) = n^c$ となり、ビット長に対する**指数関数時間（Exponential time）**を表します。
$0 < \alpha < 1$ の場合：多項式時間と指数関数時間の中間に位置する**準指数関数時間（Sub-exponential time）**となります。

過去の素因数分解アルゴリズムの進化は、この $\alpha$ の値を徐々に小さくする歴史でもありました。

連分数法（CFRAC）や複数多項式二次篩法（MPQS）：$\alpha = 1/2$ のクラスに属し、計算量は $L_n[1/2, 1]$ 程度です。
一般数体篩法（GNFS）：$\alpha = 1/3$ を達成し、現在知られている古典アルゴリズムの中で最速の $L_n[1/3, (64/9)^{1/3}]$ という計算量を誇ります。

3. GNFS（一般数体篩法）のアルゴリズム全容と数学的構造

GNFSは非常に複雑で高度な数学的基盤を持っています。基本的なアイデアは、フェルマーの小定理や二次篩法（QS）の延長線上にあり、合同式 $X^2 \equiv Y^2 \pmod n$ を満たし、かつ $X \not\equiv \pm Y \pmod n$ となる非自明な組 $(X, Y)$ を見つけることで、$n$ の因数 $\gcd(X-Y, n)$ を導出するというものです。

しかし、GNFSの真髄は、これを有理数体 $\mathbb{Q}$ のみで行うのではなく、代数体（Algebraic Number Field）と呼ばれる拡大体 $\mathbb{Q}(\alpha)$ と有理数体の両方で同時に「滑らかな数（Smooth numbers）」を探索し、準同型写像を通じて合同関係を構築する点にあります。

GNFSのプロセスは大きく5つのフェーズに分かれます。

graph TD A["素因数分解問題 (入力 n)"] --> B["1. 多項式選択 (Polynomial Selection)"] B --> C["2. 篩処理 (Sieving Phase)"] C --> D["3. フィルタリング (Filtering Phase)"] D --> E["4. 線形代数 (Linear Algebra Phase)"] E --> F["5. 平方根 (Square Root Phase)"] F --> G["素因数 p, q の出力"]

3.1 フェーズ1：多項式選択 (Polynomial Selection)

GNFSの成功は、適切な多項式の選択に大きく依存します。目標は、共通の根 $m$ を持つ2つの既約多項式 $f_1(x)$（有理側）と $f_2(x)$（代数側）を見つけることです。つまり、 $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$ を満たします。

通常、有理側の多項式は1次式 $f_1(x) = x - m$ を選び、代数側の多項式 $f_2(x)$ は次数 $d$（典型的には5や6）のモニック多項式を選びます。最も古典的なアプローチはBase-$m$ メソッドです。 $n$ の $1/(d+1)$ 乗に近い整数 $m = \lfloor n^{1/(d+1)} \rfloor$ を選び、$n$ を $m$ 進数展開します。 $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ これにより、多項式 $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$ を得ます。明らかに $f_2(m) = n \equiv 0 \pmod n$ となります。

しかし、現代の実装では Kleinjungのアルゴリズム が用いられます。これは、多項式の係数が極端に大きくならないようにしつつ（Skewnessの最適化）、代数的な性質（Murphy’s $E$ value や $\alpha$-value）を最適化し、篩処理で滑らかな数が生成されやすい多項式を探索します。このステップだけでも多大な計算資源が投入されます。

3.2 フェーズ2：篩処理 (Sieving Phase)

多項式が決定すると、アルゴリズムの最も計算負荷が高い「篩（Sieving）」フェーズに入ります。ここでは、ペア $(a, b)$ を探索します。このペアは互いに素であり、以下の2つの値が同時に「滑らか（Smooth）」であることを求められます。

有理側のノルム: $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
代数側のノルム: $F_2(a, b) = b^d \cdot f_2(a/b)$

「滑らか」とは、指定された上限（Sieve bound）以下の素数のみで素因数分解可能であることを意味します。有理側の素数ベース（Factor base）と代数側の素数ベースを用意し、巨大な探索空間上でエラトステネスの篩の要領で滑らかな数を効率的に見つけ出します。現在では**格子篩（Lattice Sieving）**と呼ばれる手法が主流であり、特定の素数 $q$ を固定して、有理側・代数側の両方が $q$ の倍数となるような部分格子上の $(a, b)$ ペアのみを篩にかけることで、極めて高い効率を実現しています。

3.3 フェーズ3：フィルタリング (Filtering Phase)

篩処理で見つかった滑らかな関係式（リレーション）の数は数億、数十億に上ります。しかし、これらは無駄な情報も多く含んでいます。フィルタリングの目的は、巨大な疎行列（Sparse Matrix）を構築しつつ、その次元を可能な限り小さくすることです。

具体的には以下のような操作を行います。

Singleton removal: 1回しか現れない素因数を含むリレーションを削除する。
Clique removal / Merging: 2回以上現れる素因数を持つリレーション同士を掛け合わせて、変数を消去し、より密度の高い、しかし次元の小さい方程式系へと縮約する。

これにより、数十億行の行列が、数千万行レベルの巨大な疎行列 $\mathbf{A}$（要素は体 $\mathbb{F}_2$ 上の0と1）へと圧縮されます。

3.4 フェーズ4：線形代数 (Linear Algebra Phase)

ここでは、方程式 $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$ の非自明な解ベクトル $\mathbf{x}$ を見つけます。つまり、巨大な疎行列の左零空間（Left Nullspace）を求める問題です。

行列のサイズが極端に大きいため、通常のガウスの消去法（$O(N^3)$）では到底計算不可能です。そこで、クリロフ部分空間法の一種である反復法が用いられます。歴史的には**ブロック・ランチョス法（Block Lanczos）が使われてきましたが、現在の分散コンピューティング環境においては、通信オーバーヘッドを劇的に削減できるブロック・ヴィーデマン法（Block Wiedemann Algorithm）**が主流です。

ブロック・ヴィーデマン法は、行列 $\mathbf{A}$ とベクトル系列から最小多項式を計算し、ベルカンプ・マッシー（Berlekamp-Massey）アルゴリズムを用いて零空間の基底を構成します。このステップは並列化が非常に困難であり、スーパーコンピュータや大規模クラスターの密結合な通信ネットワークを要求する、GNFS最大のボトルネックの1つです。

3.5 フェーズ5：平方根 (Square Root Phase)

線形代数の解から、有理側と代数側のそれぞれで「完全平方」となる積が構築されます。有理側では $\prod (a-bm)$ がある整数 $X$ の平方 $X^2$ となり、代数側では対応するイデアルの積が代数体上で完全平方 $\gamma^2$ となります。この $\gamma$ を代数体上で計算し、有理整数環への準同型写像 $\phi: \alpha \mapsto m \pmod n$ を適用することで、合同式： $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$ が得られます。

代数体上の平方根の計算には、**Montgomeryの手法（Montgomery’s Method）**などの複雑なアルゴリズムが用いられ、代数的整数論の深い知識が要求されます。最終的に $\gcd(X-Y, n)$ を計算し、非自明な因数が得られれば素因数分解完了です。

4. GNFSを超える古典アルゴリズムは存在するのか？

現在までのところ、一般の整数に対する素因数分解において、漸近的計算量が $L_n[1/3, c]$ を下回る古典アルゴリズムは発見されていません。しかし、理論的・実践的な限界を突破するためのいくつかの試みや派生アルゴリズムが存在します。

4.1 複数数体篩法 (MNFS: Multiple Number Field Sieve)

GNFSを拡張したアプローチとして、D. Coppersmithによる**複数数体篩法（MNFS）**があります。GNFSでは2つの多項式（有理側と代数側）を用いますが、MNFSでは1つの有理側多項式に対して、複数の異なる代数側多項式を同時に使用します。

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

複数の代数体を利用することで、各篩のステップにおいて「いずれかの代数体で滑らかになる」確率を飛躍的に高めることができます。Coppersmithは、このアプローチにより計算量 $L_n[1/3, c]$ の定数 $c$ をわずかに減少させることに成功しました。具体的には、GNFSの定数が $c = (64/9)^{1/3} \approx 1.923$ であるのに対し、MNFSを最適化することで $c \approx 1.902$ 程度まで計算量を削減できることが理論的に示されています。しかし、実践においては複数体の管理によるオーバーヘッドが大きく、実用規模でのRSAモジュラスに対する決定的なブレイクスルーには至っていません。

4.2 $L_n[1/4]$ クラスのアルゴリズムは可能か？

素因数分解の古典的アルゴリズムの限界について、数学者たちの間で長年議論されてきたテーマが「指数 $\alpha = 1/4$ のアルゴリズムは存在するのか？」という問いです。現在のGNFSやその派生は、篩による「滑らかさの探索」という枠組みに強く縛られており、このパラダイムの中では $\alpha = 1/3$ が限界であると広く信じられています。ディクマン関数（Dickman function）を用いた滑らかな整数の分布確率の解析からも、現在の代数体構築法と篩の組み合わせでは、どう最適化しても $O(L_n[1/3])$ の壁を越えることはできないと考えられています。

もし $L_n[1/4]$ や、あるいは古典的な多項式時間アルゴリズムが存在するとすれば、それはGNFSのような「滑らかさベース」のアプローチとは全く異なる、現在人類が思いもよらない新しい数学的構造（例えば、楕円曲線暗号に対するSchoofのアルゴリズムのような、より高度な代数幾何学的アプローチなど）に依存するはずです。しかし、現状そのような兆候は見られません。

5. 量子計算機によるブレイクスルー：ショアのアルゴリズム

古典コンピュータが $L_n[1/3]$ の壁に直面している一方で、計算モデル自体を根本から変えることでこの壁を粉砕したのが、1994年にPeter Shorによって発表された**ショアのアルゴリズム（Shor’s Algorithm）**です。

5.1 量子的多項式時間の衝撃

ショアのアルゴリズムは、素因数分解問題を「位数発見問題（Order Finding Problem）」に帰着させます。ある整数 $a$ に対して、関数 $f(x) = a^x \pmod n$ の周期（位数） $r$ を見つける問題です。古典コンピュータではこの周期を見つけるために指数関数的な時間を要しますが、量子コンピュータ上の**量子位相推定（QPE: Quantum Phase Estimation）と量子フーリエ変換（QFT: Quantum Fourier Transform）**を用いることで、全ての状態の重ね合わせ（Superposition）に対して並列に評価を行い、高い確率で周期 $r$ を抽出することが可能です。

計算量的に見ると、ショアのアルゴリズムの実行時間は量子的多項式時間、具体的には以下のようになります。

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

近年の最適化された回路実装を考慮すると、$O((\log n)^2 \log \log n)$ にまで削減可能とされています。

graph LR A["古典アルゴリズム (GNFS)"] -->|限界| B["準指数関数時間 L_n[1/3]"] C["量子アルゴリズム (Shor)"] -->|ブレイクスルー| D["多項式時間 O((log n)^3)"] B --> E["RSA暗号の継続利用 (鍵長増加)"] D --> F["RSA暗号の完全崩壊"]

5.2 古典的準指数関数時間 vs 量子的多項式時間

これら2つの計算量クラスの差は、現実世界の暗号セキュリティにおいて決定的な意味を持ちます。

たとえば、RSA-2048（2048ビットの合成数）を因数分解する場合を考えます。

GNFS (古典): $n \approx 2^{2048}$ を $L_n[1/3, 1.923]$ に代入すると、およそ $2^{112}$ 回の演算が必要となります。これは現在の地球上の全計算資源を結集しても宇宙の寿命以上の時間を要する天文学的な計算量です。
Shor’s Algorithm (量子): $O((\log n)^3)$ のアルゴリズムでは、$2048^3 \approx 8.5 \times 10^9$ 回程度の論理ゲート操作で済みます。これは適切なハードウェア（数百万の物理量子ビットと誤り訂正能力を備えた万能量子コンピュータ）が存在すれば、わずか数時間から数日で計算が完了することを意味します。

「指数 $\alpha=1/3$」の準指数関数から「多項式時間」へのパラダイムシフトは、鍵長を伸ばすことで安全性を担保するという従来の暗号学の戦略を無力化します。

6. まとめ：次世代への展望

「GNFSを超える古典アルゴリズムは存在するのか？」という問いに対する現在の科学界のコンセンサスは以下の通りです。

実践的な改良は続くが、漸近的な飛躍は無い: MNFSや多項式選択の最適化、ブロック・ヴィーデマン法の並列化など、GNFSの定数項 $c$ を改善する試みは続いています。しかし、$\alpha = 1/3$ を下回る古典的アルゴリズムが発見される可能性は極めて低いと考えられています。
古典計算機上でのRSAの安全性は依然として強固: GNFSの計算量は依然として莫大であり、RSA-2048やRSA-4096は古典コンピュータに対する攻撃に対しては今後数十年にわたり安全性を保ち続けます。
真の脅威は量子アルゴリズムである: 計算複雑性の壁を越えたのは量子力学の原理に基づくショアのアルゴリズムです。これにより、世界は耐量子計算機暗号（PQC: Post-Quantum Cryptography）への移行を余儀なくされています。格子暗号やハッシュベース暗号など、量子コンピュータでも解読が困難（多項式時間で解けない）とされる新しい数学的問題への移行が、現在の暗号学の最前線となっています。

一般数体篩法（GNFS）は、人類が古典数学とアルゴリズム設計の極限まで挑み、到達した「最高到達点」の一つです。GNFSの奥深い数学的構造を理解することは、単に暗号解読の歴史を学ぶだけでなく、計算複雑性理論や代数的整数論の美しさに触れる知的探求の旅でもあります。量子コンピュータが実用化されるその日まで、GNFSは最強の素因数分解アルゴリズムとしての王座を守り続けることでしょう。

ショアのアルゴリズムをPythonでシミュレーションしてみた

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

1. はじめに：量子コンピュータがもたらす暗号の危機

現代のインターネット社会におけるセキュリティの大部分は、公開鍵暗号方式（特にRSA暗号）に依存しています。私たちがオンラインショッピングでクレジットカード情報を送信する際や、機密性の高いデータをやり取りする際、その通信内容はRSA暗号によって強固に守られています。

RSA暗号の安全性の根拠は、「巨大な整数の素因数分解は、古典コンピュータ（私たちが普段使っているPCやスーパーコンピュータ）では極めて困難である」という数学的な事実に依存しています。しかし、1994年にピーター・ショア（Peter Shor）が発表した「ショアのアルゴリズム（Shor’s Algorithm）」は、この前提を根底から覆すものでした。ショアのアルゴリズムを大規模な量子コンピュータ上で実行すれば、古典コンピュータでは宇宙の年齢以上の時間を要する素因数分解を、わずか数分から数時間で解くことができると数学的に証明されたのです。

本記事では、このショアのアルゴリズムがいかにして素因数分解を高速に行うのか、その数学的な仕組みから、Pythonと量子計算フレームワークであるQiskitを用いた具体的なシミュレーション実装までを、徹底的に詳細に解説していきます。

2. 計算量の劇的な変化：指数関数から多項式時間へ

なぜ素因数分解が難しいのでしょうか？古典コンピュータにおける最良の素因数分解アルゴリズムとして知られる「一般数体ふるい法（General Number Field Sieve, GNFS）」を用いたとしても、その計算量は準指数関数的になります。

桁数 $N$ の合成数を素因数分解するのにかかる時間計算量は、古典的な手法では以下のようになります。

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

このため、鍵長を長くする（例えば2048ビットや4096ビットにする）だけで、古典コンピュータでの解読には数千年、数万年といった現実的ではない時間がかかるようになります。

しかし、量子コンピュータ上でショアのアルゴリズムを用いると、計算量は入力のビット数 $\log N$ に対して多項式時間へと劇的に削減されます。

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

これは、ビット数を2倍にした場合、古典コンピュータでは計算時間が天文学的に増大するのに対し、量子コンピュータでは計算時間がせいぜい8倍程度にしか増えないことを意味します。この**指数関数時間から多項式時間への計算量クラスの削減（BQPクラスへの包含）**こそが、ショアのアルゴリズムの真の凄みです。

graph TD A["入力サイズ(ビット数) Nの増加"] --> B{"アルゴリズムの選択"} B -->|古典: 一般数体ふるい法| C["準指数関数的増加 O(exp(...))"] B -->|量子: ショアのアルゴリズム| D["多項式時間 O((log N)^3)"] C --> E["数千年〜数十億年 (解読不能)"] D --> F["数分〜数時間 (現実的な時間で解読)"]

3. アルゴリズムの全体像と数学的背景

ショアのアルゴリズムは、実はすべてを量子コンピュータで行うわけではありません。古典コンピュータによる前処理・後処理と、量子コンピュータによる核心部分（周期発見アルゴリズム）の連携によって成り立っています。

アルゴリズムの全体的な流れは以下のようになります。

graph TD A["入力: 素因数分解したい合成数 N"] --> B["a < N なる乱数 a を選ぶ"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["自明な因数 gcd(a, N) を出力して終了"] C -- "No" --> E["量子アルゴリズムで f(x) = a^x mod N の周期 r を見つける"] E --> F{"r が偶数かつ a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["因数 p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N) を計算"] G --> H["出力: p, q"]

素因数分解から周期発見問題への帰着

ショアの天才的なひらめきは、「素因数分解問題」を「周期発見問題（Order Finding Problem）」に変換したことにあります。

整数 $N$（素因数分解したい数）と、互いに素な整数 $a$（$1 < a < N$）を考えます。次のようなモジュラー指数関数を定義します。

$$ f(x) = a^x \bmod N $$

この関数は、ある周期 $r$ を持ちます。つまり、任意の $x$ に対して $f(x+r) = f(x)$ が成り立ちます。特に $x=0$ のとき、

$$ a^r \equiv 1 \pmod N $$

となる最小の正の整数 $r$ を「$a$ の $N$ を法とする位数（Order）」と呼びます。この周期 $r$ を見つけることができれば、次のようにして素因数を導き出すことができます。

式を変形すると、

$$ a^r - 1 \equiv 0 \pmod N $$

もし $r$ が偶数であれば、平方差の公式を用いて因数分解できます。

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

これは、$N$ が $(a^{r/2} - 1)$ または $(a^{r/2} + 1)$ のいずれかと公約数を持つことを意味します（ただし $a^{r/2} \not\equiv -1 \pmod N$ という条件を満たす必要があります）。したがって、ユークリッドの互除法を用いて、

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

を計算すれば、$N$ の非自明な素因数 $p, q$ を見つけることができるのです。この計算（最大公約数の計算や乱数の生成）は、古典コンピュータで非常に高速に行えます。問題は、周期 $r$ をどのようにして高速に見つけるかという点に絞られます。古典コンピュータでは、この周期 $r$ を見つけること自体が指数関数的な時間を要してしまいます。ここで量子コンピュータの出番となります。

4. 量子アルゴリズム部分：周期発見の仕組み

量子コンピュータを用いて周期 $r$ を見つけるためのサブルーチンは、以下の4つのステップで構成されます。

graph LR subgraph "量子状態の推移" S1["|0⟩|0⟩ (初期化)"] --> S2["Hゲート: 重ね合わせ Σ|x⟩|0⟩"] S2 --> S3["オラクル U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: 干渉による周期抽出"] S4 --> S5["測定: 近似値 y の取得"] end

ステップ1：量子レジスタの初期化と重ね合わせ

まず、2つの量子レジスタを用意します。第1レジスタは状態を入力するためのもので、第2レジスタは関数の計算結果を格納するためのものです。初期状態は全て $|0\rangle$ です。

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

第1レジスタのすべての量子ビットにアダマールゲート（Hadamard Gate）を適用し、考え得るすべての入力 $x$ （$0$ から $Q-1$ まで、$Q=2^n$）の等確率な重ね合わせ状態を作り出します。

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

これにより、量子コンピュータは一度の演算で $Q$ 個すべての入力に対する状態を同時に保持することになります。これが量子並列性の強力な源泉です。

ステップ2：オラクル関数（モジュラーべき乗）の適用

次に、量子演算回路 $U_f$ を用いて、関数 $f(x) = a^x \bmod N$ を計算し、その結果を第2レジスタに格納します。

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

この時点で、第1レジスタと第2レジスタは**量子もつれ（エンタングルメント）**の状態にあります。もし（仮に）第2レジスタを観測して特定の値 $k = a^{x_0} \bmod N$ を得たとすると、第1レジスタの状態は、その値 $k$ を与えるような $x$ の重ね合わせ状態に崩壊します。関数の周期が $r$ であるため、残る状態は $x_0, x_0+r, x_0+2r, \dots$ という $r$ 飛ばしの値になります。

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

しかし、私たちは $x_0$ を知りたいわけではなく、周期 $r$ 自体を知りたいのです。この状態から $r$ を直接観測することは不可能です。そこで、量子フーリエ変換を用います。

ステップ3：量子フーリエ変換（QFT）による位相干渉

第1レジスタに対して**量子フーリエ変換（Quantum Fourier Transform, QFT）**を適用します。QFTは古典的な離散フーリエ変換の量子版であり、状態ベクトルの振幅を変換します。基底状態 $|x\rangle$ に対するQFTの作用は以下のように定義されます。

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

ここで、$\omega = e^{2\pi i / Q}$ です。

QFTを適用すると、状態の振幅が干渉を起こします。数学的な詳細は省きますが、周期 $r$ を持つ状態に対してQFTを適用すると、波が**建設的干渉（Constructive Interference）を起こすのは、$y$ が $Q/r$ の整数倍に極めて近い値のときだけになります。それ以外の状態は破壊的干渉（Destructive Interference）**により確率振幅が相殺され、ゼロに近づきます。

ステップ4：測定と連分数展開

最後に第1レジスタを測定します。測定によって得られる値 $y$ は、高い確率で以下の条件を満たします。

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

（$c$ は $0 \le c < r$ の未知の整数です）

得られた有理数 $y/Q$ に対して古典アルゴリズムである**連分数展開（Continued Fraction Expansion）**を適用することで、近似分数 $c/r$ を計算し、分母から周期 $r$ を抽出します。

5. PythonとQiskitを用いたシミュレーション実装

理論だけでは実感が湧かないため、実際にPythonとIBMの量子計算フレームワークであるQiskitを用いて、ショアのアルゴリズムをシミュレーションしてみましょう。

ここでは、最も古典的で有名な例である 「$N=15$ を $a=7$ を用いて素因数分解する」 というシナリオを実装します。

実行環境の準備

あらかじめQiskitをインストールしておいてください。

1

pip install qiskit qiskit-aer numpy

Python実装コードの全体像

以下のコードは、$N=15, a=7$ に特化したショアのアルゴリズムの実装例です。汎用的なモジュラーべき乗回路を組むのは現在のシミュレータでは計算コストが高すぎるため、特定の $a=7$ の場合のゲート動作をハードコーディングしています。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. 逆量子フーリエ変換 (QFT†) を構築する関数
def qft_dagger(n):
 """n量子ビットの逆量子フーリエ変換回路を生成する"""
 qc = QuantumCircuit(n)
 # 順序を反転するためのSWAPゲート
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # 制御位相ゲートとHゲートの適用
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. 7^x mod 15 の制御モジュラーべき乗演算を構築する関数
def c_amod15(a, power):
 """特定のaとべき乗に対する制御Uゲートを生成する(N=15専用)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # a=7の場合の 7^x mod 15 のハードコーディング論理
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. メインの量子回路構成
def shor_circuit(a, n_count):
 # n_count: 制御レジスタのビット数
 # ターゲットレジスタは 0〜15 を表現するため 4ビット
 qc = QuantumCircuit(n_count + 4, n_count)

 # 第1レジスタ（制御レジスタ）の初期化（重ね合わせの生成）
 for q in range(n_count):
 qc.h(q)

 # 第2レジスタ（ターゲットレジスタ）を |1> (0001) に初期化
 qc.x(3 + n_count)

 # 制御モジュラーべき乗演算（オラクル）の適用
 for q in range(n_count):
 # 2^q 乗の演算を適用
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # 第1レジスタに逆量子フーリエ変換を適用
 qc.append(qft_dagger(n_count), range(n_count))

 # 第1レジスタを測定
 qc.measure(range(n_count), range(n_count))
 return qc

# --- 実行セクション ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # 制御レジスタに8量子ビットを使用 (Q=256)

 print(f"探索設定: N={N}, a={a}, 制御量子ビット数={n_count}")

 # 回路の生成
 qc = shor_circuit(a, n_count)

 # シミュレータでの実行
 sim = AerSimulator()
 # 最新のQiskitではtranspileを推奨
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\n測定結果(ビット列: 観測回数):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count}回")

 # 古典的後処理: 連分数展開による周期rの特定
 print("\n--- 周期の計算と素因数分解 ---")
 phases = []
 for output in counts:
 # ビット列を10進数に変換
 decimal = int(output, 2)
 # 位相 = 測定値 / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # 連分数展開によって近似分数を取得。分母の上限は N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"観測値: {decimal:3d} | 位相: {phase:.4f} | 連分数: {frac} | 推定周期 r = {r}")

 # 周期 r が偶数かつ有効な結果をもたらすか確認
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => 成功！ {N} の素因数は {guess1} と {guess2} です。")
 else:
 print(f" => 自明な因数のみ。やり直し。")
 else:
 print(f" => 周期が奇数のため失敗。")

コードの解説と実行結果の解析

上記のコードを実行すると、制御レジスタの測定結果として、高い確率で特定のピーク（観測値）が得られます。n_count=8（$Q=256$）の場合、理想的な量子コンピュータ（またはシミュレータ）であれば、観測値として 0, 64, 128, 192 のような数値が圧倒的な確率で出現します。

これらを $Q=256$ で割ると、位相 $y/Q$ はそれぞれ $0.0$, $0.25$, $0.5$, $0.75$ となります。この位相を連分数展開すると：

$0.25 \to 1/4$ （推定周期 $r=4$）
$0.50 \to 1/2$ （推定周期 $r=2$）
$0.75 \to 3/4$ （推定周期 $r=4$）

ここで得られた周期 $r=4$ を用いて、素因数を計算します。 $a=7, r=4$ なので、 $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

見事に、$15 = 3 \times 5$ の素因数分解に成功しました。

[!TIP] 測定値として $y=128$（位相 $0.5$）が得られた場合、分母は $2$ となり、真の周期 $r=4$ ではなくその約数を得てしまいます。このような場合は、アルゴリズムを複数回実行するか、得られた $r$ の倍数を調べることで真の周期にたどり着くことができます。

6. 実用化に向けた課題と NISQ 時代の限界

シミュレータ上で $N=15$ を素因数分解することは簡単にできましたが、実社会で使われているRSA-2048（617桁の10進数）を素因数分解するには、現実の量子コンピュータにはまだ数多くの壁が存在します。

現在私たちが生きている時代は、NISQ（Noisy Intermediate-Scale Quantum：ノイズあり中規模量子）時代と呼ばれています。量子ビットは外部環境のノイズに対して極めて脆弱であり、計算途中で「デコヒーレンス」を起こして状態が壊れてしまいます。

ショアのアルゴリズムのような深い（ゲート数が多い）回路を正確に実行するためには、ノイズを訂正する**量子誤り訂正（Quantum Error Correction）**が不可欠です。一つのノイズのない「論理量子ビット」を作り出すために、数千個の「物理量子ビット」を表面符号（Surface Code）などでエンコードする必要があります。

2048ビットのRSA暗号を破るためには、数千個の完璧な論理量子ビットが必要であり、それを実現するには数百万から数千万個の物理量子ビットを搭載したフォールトトレラント（誤り耐性）量子コンピュータが必要になると見積もられています。現在の最先端の量子プロセッサでも数百〜数千物理量子ビット程度であるため、直ちに世界中の暗号が破られるわけではありません。

[!WARNING] しかし、「Store Now, Decrypt Later（今保存して、後で解読する）」という脅威モデルが存在します。攻撃者は現在暗号化されている機密通信を暗号データのまま大量に保存しておき、10〜20年後に強力な量子コンピュータが完成した瞬間に全てを解読するという戦略をとる可能性があります。

7. 耐量子計算機暗号（PQC）への移行

このような「Q-Day（量子コンピュータが暗号を破る日）」の到来に備え、アメリカ国立標準技術研究所（NIST）を筆頭に、世界中の暗号学者が**耐量子計算機暗号（Post-Quantum Cryptography, PQC）**の策定を進めています。

PQCは、ショアのアルゴリズムを用いても（あるいはグローバーのアルゴリズムを用いても）効率的に解くことができないと数学的に考えられている新しい数学的問題（格子問題、多変数多項式問題、ハッシュ関数ベースなど）を基盤としています。すでに「CRYSTALS-Kyber」や「CRYSTALS-Dilithium」といったアルゴリズムが標準規格として選定され、AppleのiMessageや各種ウェブブラウザの通信プロトコルへの導入が徐々に始まっています。

ITインフラを管理するエンジニアにとって、既存のRSAや楕円曲線暗号からPQCへの「クリプト・アジリティ（暗号の俊敏性：素早く暗号方式を切り替えられる設計）」をシステムに組み込むことが、今後の大きなミッションとなるでしょう。

8. おわりに

本記事では、ショアのアルゴリズムの理論的な数学的背景から始まり、量子フーリエ変換を用いた周期抽出のメカニズム、そしてPythonとQiskitを用いた具体的なシミュレーションコードまで、1万文字規模のボリュームで徹底的に解説を行いました。

量子力学というミクロな世界の物理法則が、マクロな情報科学の根幹である計算量理論や暗号理論を根本から覆してしまうという事実は、科学の歴史において最もエキサイティングなパラダイムシフトの一つです。現在進行形で発展し続ける量子コンピューティング技術と、それに立ち向かう新しい暗号技術の攻防戦から、今後も目が離せません。

ぜひ、今回紹介したPythonコードをご自身の環境で実行し、量子状態の重ね合わせと干渉が生み出す「計算の魔法」を体感してみてください。

参考文献

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【図解PQC】耐量子計算機暗号の主要なアルゴリズム比較

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

1. はじめに：量子コンピュータがもたらす「暗号の危機」

現代のインターネット社会において、通信の機密性やデータの完全性を守るために公開鍵暗号技術はインフラとして必要不可欠です。現在広く利用されているRSA暗号や楕円曲線暗号（ECC）は、それぞれ「巨大な合成数の素因数分解の困難性」や「楕円曲線上の離散対数問題の困難性」という数学的な壁に依存して安全性を担保しています。古典的なコンピュータ（スーパーコンピュータを含む現在私たちが使っているコンピュータ）では、これらの数学的問題を解くためには宇宙の年齢よりも長い時間がかかると証明されており、それが安全性の根拠となってきました。

しかし、この堅牢な前提は量子コンピュータの理論と実用化の進展によって根底から覆されようとしています。1994年に暗号学者ピーター・ショア（Peter Shor）が発表した「Shorのアルゴリズム」は、十分な性能を持つ誤り耐性汎用量子コンピュータ（CRQC: Cryptographically Relevant Quantum Computer）上で実行することで、素因数分解問題や離散対数問題を「多項式時間」で解読できることを理論的に証明しました。これは、現在使われている公開鍵暗号がすべて無力化されることを意味します。

「量子コンピュータの本格的な完成はまだ数十年先だから問題ない」と考えるのは非常に危険です。なぜなら、**Store Now, Decrypt Later (SNDL：今すぐ保存し、後で復号する)**と呼ばれる攻撃手法がすでに現実の脅威となっているからです。これは、悪意のある国家やハッカー組織が、現在の暗号化された通信データ（TLSのトラフィックなど）を大量にストレージに保存しておき、将来強力な量子コンピュータが利用可能になった瞬間にそれらをすべて復号するという攻撃です。国家機密、インフラ情報、長期間保護すべき医療データなどは、すでにこの脅威に晒されています。

また、対称鍵暗号（AESなど）やハッシュ関数（SHA-256など）に対しても、1996年に発見されたGroverのアルゴリズムが存在します。これにより、総当たり攻撃（ブルートフォース）の計算量が平方根に削減されます。つまり、AES-128のセキュリティレベルは実質的に2の64乗に半減するため、量子時代においてはAES-256やSHA-384といった、より長い鍵やハッシュ長を使用することが推奨されています。

この未曾有の暗号危機に対抗するために誕生したのが、量子コンピュータを用いても解読が困難な新しい数学的問題に基づいた**耐量子計算機暗号（Post-Quantum Cryptography: PQC）**です。本記事では、米国国立標準技術研究所（NIST）が主導して進めてきたPQC標準化プロセスの結果に基づき、主要なPQCアルゴリズムについて、その数学的背景から仕組み、アーキテクチャの比較までを極めて詳細に解説します。

2. NISTによるPQC標準化プロジェクトの全貌と歴史

暗号技術の移行には、プロトコルの再設計、システムのアップデート、ハードウェアの交換などを含め、数年から数十年の時間がかかります。そのため、世界中の暗号学者たちは早期からPQCの研究を進めてきました。その中心的な役割を担ってきたのが米国のNIST（国立標準技術研究所）です。NISTは2016年にPQCの標準化プロセスを公募し、全世界の暗号コミュニティから全く新しい暗号アルゴリズムの提案を受け付けました。

標準化の対象となったのは以下の2つの主要カテゴリです。

公開鍵暗号 / 鍵カプセル化メカニズム (KEM: Key Encapsulation Mechanism): TLS接続などで、通信経路を暗号化するための共通鍵を安全に共有（配送）するための仕組み。
デジタル署名 (Digital Signatures): ソフトウェアのアップデートや電子証明書において、データの改ざんがないことや、送信者のなりすましがないこと（真正性）を証明するための仕組み。

約6年間にわたる非常に激しい評価・解析と暗号解読の競争（Round 1〜Round 3）を経て、さらに一部のアルゴリズムについてはRound 4の追加評価が行われました。その結果、2024年に以下のアルゴリズムが正式な連邦情報処理標準（FIPS）として発行され、今後の世界の標準として確定しました。

FIPS 203 (ML-KEM): CRYSTALS-Kyberに基づくKEM
FIPS 204 (ML-DSA): CRYSTALS-Dilithiumに基づくデジタル署名
FIPS 205 (SLH-DSA): SPHINCS+に基づくステートレスハッシュベース署名
（今後の策定予定）FN-DSA: FALCONに基づくデジタル署名

これらの選定されたアルゴリズムは、依拠する数学的な「困難性問題」がそれぞれ異なっており、ある一つのアルゴリズムに将来致命的な脆弱性が発見された場合でも、システム全体が崩壊しないように多様性（Crypto Agility）が確保されています。標準化プロセスでは、主に格子暗号（Lattice-based cryptography）が性能の面から主役となりましたが、ハッシュベース暗号や符号ベース暗号が強力なバックアップとして採用されています。

3. PQCの主要な数学的アプローチの分類

PQCアルゴリズムは、その安全性の根拠となる数学的な問題によって、主に以下の5つのカテゴリに大別されます。本記事では特に上位3つについて詳しく掘り下げます。

格子暗号 (Lattice-based Cryptography): 多次元の格子空間における最短ベクトル問題（SVP）や最近接ベクトル問題（CVP）、およびそこから派生したLWE問題に基づきます。NIST標準化の中心であり、Kyber、Dilithium、FALCONが該当します。処理速度、公開鍵サイズ、暗号文サイズのバランスが最も優れており、汎用的な利用に適しています。
ハッシュベース暗号 (Hash-based Cryptography): 暗号学的ハッシュ関数（SHA-2やSHAKEなど）の「衝突耐性」と「一方向性」のみに安全性の根拠を置きます。デジタル署名（SPHINCS+など）にのみ適用可能ですが、安全性の証明が最も強固であり、未知の数学的攻撃に対する耐性が極めて高いのが特徴です。
符号ベース暗号 (Code-based Cryptography): 誤り訂正符号の理論に基づき、シンドローム復号問題（Syndrome Decoding Problem）の困難性に依存します。1970年代に提案されたClassic McElieceが代表的で、非常に長い歴史と実績のある安全性を持つ反面、公開鍵のサイズがメガバイト単位と極端に大きくなります。
多変数多項式暗号 (Multivariate Polynomial Cryptography): 有限体上の多変数連立二次方程式の解を求めること（MQ問題）の困難性に基づきます。主にデジタル署名（Rainbowなど）として提案されましたが、NISTの最終ラウンドの最中にパソコン1台で数日で解読されるという強力な攻撃手法が発見され、多くのアルゴリズムが標準化から脱落しました。
同種写像暗号 (Isogeny-based Cryptography): 楕円曲線の同種写像（Isogeny）グラフ上での経路探索問題に基づきます。鍵サイズが非常に小さく、ECCの正当な後継として期待されていましたが、最終候補であった「SIKE」が2022年に古典的な数学（Castryck-Decru攻撃など）を用いて通常のPCでわずか数時間で完全に解読されてしまい、PQC設計の難しさと恐ろしさを象徴する劇的な幕引きとなりました。

4. 格子暗号の深淵：LWE問題とModule-LWEの数学的基礎

現在最も有力視され、標準化の中心となった格子暗号。その安全性の根底にあるのが**LWE問題 (Learning with Errors: 誤差付き学習問題)**です。2005年にOded Regevによって提唱され、この画期的な功績により彼はGödel賞を受賞しました。LWE問題の理解なくして現代のPQCを語ることはできません。

4.1. LWE問題 (Learning with Errors) とは何か

まず、簡単な連立一次方程式を考えてみましょう。ある法 $q$ （モジュロ $q$）のもとで、既知のランダムな行列 $A$ と、未知の秘密のベクトル $\vec{s}$ があり、その積 $\vec{b}$ が与えられたとします。

$$ \vec{b} = A\vec{s} \pmod q $$

このとき、公開情報である $A$ と $\vec{b}$ から、未知の $\vec{s}$ を求めるのは簡単です。古典的なアルゴリズムである「ガウスの消去法（掃き出し法）」を使えば、多項式時間で容易に $\vec{s}$ を計算できます。

しかし、この式に「小さな意図的な誤差（ノイズ）」を加えると、問題の難易度が劇的に跳ね上がります。これがLWE問題です。

未知の秘密ベクトル $\vec{s} \in \mathbb{Z}_q^n$ と、ランダムに選ばれた行列 $A \in \mathbb{Z}_q^{m \times n}$ を用意します。さらに、正規分布や二項分布などに従って選ばれた「要素の値が十分に小さい」誤差ベクトル $\vec{e} \in \mathbb{Z}_q^m$ を用意し、次のように $\vec{b}$ を計算します。

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

Search LWE問題とは、「公開情報 $(A, \vec{b})$ から秘密情報 $\vec{s}$ を求めよ」という問題です。この誤差 $\vec{e}$ が存在することにより、ガウスの消去法などの代数的な解法を行おうとすると、方程式を足し引きする過程で誤差 $\vec{e}$ が雪だるま式に増幅されてしまい、最終的にランダムな値と区別がつかなくなり破綻してしまいます。

LWE問題の凄さは、「格子上の最悪時計算量問題（Worst-case hardness）」であるGapSVP（判定最短ベクトル問題）やSIVP（最短独立ベクトル問題）を解くことができる量子アルゴリズムが存在しない限り、LWE問題も平均的（Average-case）に解くことができない、という強力な理論的証明（還元）が存在する点です。つまり、ランダムに生成された暗号鍵であっても、理論的な上限に裏打ちされた強固な安全性を持つことが保証されています。

4.2. Ring-LWE と Module-LWE による劇的な効率化

通常のLWE問題（Standard LWE）は安全性の根拠が非常に明確ですが、行列 $A$ のサイズが非常に大きくなり、鍵サイズがメガバイト級になるため実用的ではありません。そこで提案されたのが、多項式環（Polynomial Rings）を利用して代数的な構造を持たせるアプローチです。

Ring-LWE問題では、単なるベクトルや行列の代わりに、ある多項式環 $R_q$ の元（多項式）を使用します。NIST標準で一般的に用いられるのは以下のような円分多項式環です。

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

ここで、$n$ は 2 のべき乗（例：256）、$q$ は適当な素数です。この環の上で、要素 $a, s, e \in R_q$ を用いて $b = a \cdot s + e \pmod q$ を計算します。一つの多項式 $a$ が $n$ 個の係数を持つため、データを大幅に圧縮でき、さらに**NTT (Number Theoretic Transform: 数論変換)**という高速フーリエ変換（FFT）の有限体バージョンを用いることで、$O(n \log n)$ の計算量で超高速に多項式の乗算が可能になります。

しかし、Ring-LWEには「環の特殊な代数構造に起因する未知の脆弱性が存在するかもしれない」という懸念がありました。また、セキュリティレベル（AES-128, 192, 256相当など）を変更する際に、多項式の次数 $n$ そのものを変える必要があり、それに伴いNTTのアルゴリズムなど実装全体を書き直さなければならないという工学的な課題がありました。

そこで、標準化アルゴリズムであるKyberやDilithiumが採用したのがModule-LWE (M-LWE) 問題です。Module-LWEは、無構造なStandard LWEと、構造を持ちすぎるRing-LWEのちょうど中間に位置する妥協案であり、多項式環 $R_q$ の要素を成分とする $k \times k$ の行列（モジュール）を使用します。

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Module-LWEの最大の利点は、多項式の次数 $n$（NIST標準では $n=256$）を固定したまま、行列の次元 $k$ を変えるだけで容易にセキュリティレベルをスケールさせることができる点です。例えばKyberの場合、以下のように次元 $k$ を調整します。

Kyber512 (Level 1): $k = 2$ （AES-128相当）
Kyber768 (Level 3): $k = 3$ （AES-192相当）
Kyber1024 (Level 5): $k = 4$ （AES-256相当）

これにより、基盤となるNTTのコードや多項式演算のハードウェア回路を全セキュリティレベルで100%再利用することが可能になり、実装の安全性と効率性が劇的に向上しました。

5. CRYSTALS-Kyber (ML-KEM)：次世代の鍵カプセル化メカニズム

FIPS 203 (ML-KEM) として正式に標準化されたCRYSTALS-Kyberは、前述のModule-LWE問題に基づく鍵カプセル化メカニズム (KEM) です。今後、TLS 1.3やSSHなどでセッションキーを安全に共有するための事実上の世界標準となります。

5.1. KEM (Key Encapsulation Mechanism) のアーキテクチャ

PQCの時代では、RSAのように「クライアントが共通鍵を作ってサーバーの公開鍵で暗号化して送る」という直接的なアプローチではなく、KEMというカプセル化の枠組みが標準となります。

sequenceDiagram participant Client as "クライアント (Alice)" participant Server as "サーバー (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "秘密鍵 (sk) と公開鍵 (pk) を生成" Client->>Server: "公開鍵 (pk) を送信" Note over Server: "ML-KEM Encaps()" Server->>Server: "ランダムな共通鍵 (K) を生成" Server->>Server: "Kをpkでカプセル化し、暗号文 (c) を作成" Server->>Client: "暗号文 (c) を送信" Note over Client: "ML-KEM Decaps()" Client->>Client: "秘密鍵 (sk) を使って暗号文 (c) を復号" Client->>Client: "カプセル化を解除し、共通鍵 (K) を取り出す" Note over Client, Server: "共有した共通鍵 (K) を用いてAESなどで暗号化通信を開始"

5.2. Kyberの内部アルゴリズムの仕組みと藤崎・岡本変換

Kyberの設計は非常に洗練されています。まず、CPA（選択平文攻撃）に対してのみ安全な公開鍵暗号方式（Kyber.CPAPKE）を構築し、それに藤崎・岡本変換 (Fujisaki-Okamoto Transform) と呼ばれる暗号学的に非常に強力な手法を適用することで、CCA（適応的選択暗号文攻撃）に対しても安全な完全なKEMへとアップグレードする設計を採用しています。

CPAPKEの核となる暗号化と復号のメカニズムは以下の通りです。

鍵生成 (Key Generation):
- ランダムなシード値から、NTTドメイン上の行列 $A \in R_q^{k \times k}$ を生成します。法 $q$ は $3329$ が使われます。
- 中心二項分布（CBD）から、小さな係数を持つ秘密ベクトル $\vec{s}$ と誤差ベクトル $\vec{e}$ をサンプリングします。
- $\vec{t} = A\vec{s} + \vec{e}$ を計算します。公開鍵は $(A, \vec{t})$、秘密鍵は $\vec{s}$ です。（実際には $A$ はシード値として公開され、帯域を節約します）。
暗号化 (Encryption):
- 共有したい32バイトのメッセージ（共通鍵の材料）$m$ を多項式にエンコードします。
- 新たなランダムなベクトル $\vec{r}$ と、小さな誤差 $\vec{e_1}, e_2$ を生成します。
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- 暗号文は $(\vec{u}, v)$ となります。
復号 (Decryption):
- 受信者は $v - \vec{s}^T\vec{u}$ を計算します。
- この式を数式展開すると以下のようになります。 $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- ここで $\vec{t} = A\vec{s} + \vec{e}$ を代入すると、主項である $\vec{s}^TA^T\vec{r}$ が相殺されます。
- 残るのは $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$ となります。
- 括弧内の項は「小さな誤差同士の積や和」であるため、全体としても十分に小さな値（ノイズ）に留まります。したがって、各係数が $0$ に近いか $q/2$ に近いかを閾値判定することで、元のメッセージ $m$ のビット（0 または 1）を完全にエラーなく復元することができます。

Kyberの最大の強みは、その圧倒的な処理速度と適度な鍵サイズです。Kyber768の場合、公開鍵サイズは1,184バイト、暗号文サイズは1,088バイトであり、RSA-3072（鍵サイズ約384バイト）などと比較すると大きいものの、現代のインターネット通信のMTU（Maximum Transmission Unit）内にパケット分割なしで収めることが可能であり、ネットワークのレイテンシにほとんど悪影響を与えません。

6. CRYSTALS-Dilithium (ML-DSA)：格子ベースの汎用デジタル署名

デジタル署名の標準化においては、同じ格子暗号アプローチの中でも異なる設計思想を持つアルゴリズムが競い合いました。その中で汎用的なデジタル署名としてFIPS 204 (ML-DSA) に選定されたのがCRYSTALS-Dilithiumです。

6.1. Fiat-Shamir with Aborts パラダイム

DilithiumはKyberと同じくModule-LWE（およびModule-SIS問題）に基づくデジタル署名スキームです。設計のベースには「Fiat-Shamir with Aborts (中途終了を伴うフィアット・シャミア変換)」という極めて重要なパラダイムが用いられています。

Fiat-Shamir変換自体は、対話型のゼロ知識証明プロトコルを非対話型のデジタル署名へと変換するための標準的な手法です。証明者（署名者）がコミットメント $y$ を生成し、$w = Ay$ を計算してハッシュ関数に通すことで、ランダムなチャレンジ $c$ を得て、応答 $z = y + cs$ を計算します。

しかし、格子暗号においてこれを単純に適用すると、応答 $z$ の分布が秘密鍵 $s$ の値に依存して歪んでしまい、多数の署名を観測した攻撃者に秘密鍵 $s$ の情報が少しずつ漏洩してしまうという致命的な問題（サイドチャネル的な数学的漏洩）がありました。

Dilithiumの設計チーム（Lyubashevskyら）は、署名の計算結果 $z$ の係数が、あらかじめ設定された安全な閾値の範囲内に収まらなかった場合、その署名プロセス全体を破棄（Abort）して、新しい乱数 $y$ を使って最初から計算をやり直す「棄却サンプリング (Rejection Sampling)」という手法を導入しました。

これにより、最終的に出力される署名 $z$ は秘密鍵に一切依存しない完全な均一分布となり、情報漏洩を数学的に完全に防ぐことに成功しました。

6.2. Dilithiumの利点と実装の容易さ

Dilithiumの設計上の大きな利点は、署名生成プロセスにおいて複雑な「ガウス分布からのサンプリング」や「浮動小数点演算」を一切使用しない点です。一様分布からのサンプリングと、単純な整数モジュロ演算、NTT、およびハッシュ関数（SHAKE）のみで実装できるため、組み込みのマイクロコントローラからクラウドサーバーまで、幅広い環境で安全かつ定数時間（Constant-time）で実装することが容易です。これにより、タイミング攻撃などの物理的なサイドチャネル攻撃に対しても強固な耐性を持ちます。

7. FALCON (FN-DSA)：究極にコンパクトな格子署名

NISTは、Dilithiumとは異なる特性を持つもう一つの格子ベース署名としてFALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) を標準化候補として選定しました（現在FN-DSAとしてドラフト策定中）。

7.1. NTRU格子とガウスサンプリング

FALCONの最大の特徴は、LWE問題ではなく、1996年から存在する歴史の古いNTRU (N-th degree Truncated polynomial Ring Units) 格子を使用している点です。さらに、GPV (Gentry-Peikert-Vaikuntanathan) フレームワークに基づく「ハッシュ・アンド・サイン (Hash-and-Sign)」パラダイムを採用しています。

Hash-and-Signでは、メッセージのハッシュ値を空間内のターゲット点とし、その点に最も近い格子上の点（最近接ベクトル問題の近似解）を見つけることで署名とします。これには、秘密鍵である「質の良い短い基底」を用いて、離散ガウス分布に従って点をサンプリングする必要があります。

FALCONは、この重い計算を「高速フーリエ直交化 (Fast Fourier Orthogonalization: FFO)」という手法を用いて劇的に高速化しました。

7.2. FALCONのメリットとデメリット

FALCONの圧倒的なメリットは、その**署名サイズと公開鍵サイズが極めて小さい（コンパクトである）**ことです。Dilithium3の署名サイズが約3,309バイトであるのに対し、FALCON-512の署名サイズはわずか約666バイトです。公開鍵も897バイトと非常に小さく、通信帯域が極端に制限される環境や、IoTデバイス、特定のネットワークプロトコルにおいては救世主となります。

しかし、重大なデメリットが存在します。署名生成時に複雑な**浮動小数点演算（64-bit IEEE 754）**を伴う離散ガウスサンプリングが必須となるため、タイミング漏洩を防ぐ定数時間実装（Constant-time implementation）が極めて難しく、コードも巨大化します。このため、FALCONは汎用的な利用（Dilithium）に対する、特定用途向けの強力な特化型アルゴリズムという位置付けになります。

graph LR A["デジタル署名の要件"] --> B{"最優先する制約は？"} B -->|"実装のシンプルさ・汎用性・定数時間実装の容易さ"| C["Dilithium (ML-DSA)"] B -->|"通信帯域の最小化・データサイズのコンパクトさ"| D["FALCON (FN-DSA)"] C --> E["汎用的なTLS証明書、ソフトウェアの電子署名"] D --> F["パケットサイズ制限が厳しいプロトコル、特殊環境"]

8. SPHINCS+ (SLH-DSA)：最強の安全性を誇るハッシュベース署名

格子暗号の安全性が、将来的に天才的な数学者のブレイクスルーによって破られるという最悪のシナリオ（万が一の事態）に備えて、NISTは格子暗号とは全く異なるアプローチを持つ標準として FIPS 205 (SLH-DSA)、すなわち**SPHINCS+**を策定しました。

SPHINCS+はハッシュベース署名に分類されます。その安全性の根拠は、「用いている暗号学的ハッシュ関数（SHA-2やSHAKE256など）が衝突耐性と一方向性を持つこと」という、ただ1点のみに依存しています。LWEや素因数分解のような、特定の代数構造を持つ数学的問題に依存していないため、将来的にどんな強力な量子アルゴリズムが登場しようとも、ハッシュ関数の出力長を単純に伸ばすだけで対抗できるという、極めて強固な安全性（最も保守的なセキュリティ）を誇ります。

8.1. WOTS+ と FORS によるステートレスアーキテクチャ

ハッシュベース署名の歴史は古く、1970年代のLamport署名やWinternitzワンタイム署名（WOTS）に遡ります。これらは「1回だけ安全に署名できる」という使い捨ての鍵でした。これを複数回使えるようにするために、マークル木（Merkle Tree）を組み合わせて無数のワンタイム鍵を一つのルートハッシュで管理するXMSS（eXtended Merkle Signature Scheme）やLMSといったアルゴリズムが開発されました。

しかし、XMSSやLMSには「ステートフル（状態保持型）」であるという重大な欠点がありました。署名するたびに「何番目のワンタイム鍵を使用したか」というインデックス状態を不揮発性メモリに厳密に記録し続ける必要があり、もし仮想マシンのスナップショットの復元などで状態が巻き戻り、同じワンタイム鍵を二度使ってしまうと、秘密鍵が即座に漏洩してシステムが崩壊してしまいます。

SPHINCS+は、この状態管理の煩わしさを解決した「ステートレス（状態非保持型）」のハッシュベース署名です。その中核技術は以下の組み合わせです。

WOTS+ (Winternitz One-Time Signature Plus): 基本的なワンタイム署名。
FORS (Forest of Random Subsets): 少回数署名（Few-Time Signature）技術。同じ鍵を数回程度なら再利用しても安全性を保つ。
Hyper-Tree (巨大な木構造): マークル木を多層的に重ね合わせた巨大な構造。

SPHINCS+では、署名を行う際、状態を管理する代わりに、Hyper-Treeの底辺にある膨大な数のFORS鍵の中から、擬似乱数を用いてランダムに一つを選び出して署名します。木の葉の数が天文学的に多いため、同じ鍵を偶然二度選んでしまう確率（コリジョン）が無視できるほど小さくなり、結果としてステートレスを実現しています。

SPHINCS+の唯一にして最大の弱点は、署名サイズが極めて大きいことです。パラメータにもよりますが、署名サイズは17キロバイト〜49キロバイトにも達し、署名生成速度も格子暗号に比べて圧倒的に遅くなります。そのため、日常的なWebブラウジングでの利用よりも、ソフトウェアのアップデート署名やルート認証局（CA）の証明書など、頻繁に署名を行わず、かつ長期間の絶対的な安全性が強く求められる用途での利用が想定されています。

9. 符号ベース暗号：Classic McElieceという古き良き巨人

NISTの標準化プロセスにおいて、Round 4の最終候補として現在も評価が継続されている重要なアプローチが、符号ベース暗号のClassic McElieceです。

1978年にRobert McElieceによって提案されたこのアルゴリズムは、公開鍵暗号の歴史の中でもRSAと並んで最も古いものの一つです。「Goppa符号（ゴッパ符号）」と呼ばれる代数幾何符号を利用しており、メッセージに意図的にエラー（ノイズベクトル）を加えて暗号化し、秘密鍵としてGoppa符号のパリティ検査行列を持つ者だけが、強力な誤り訂正能力を使ってエラーを取り除き、元のメッセージを復号できる、という「シンドローム復号問題 (Syndrome Decoding Problem)」に基づいています。

$$ \vec{c} = \vec{m} G + \vec{e} $$

（$G$ は公開鍵であるスクランブルされた生成行列、$\vec{e}$ は重み $t$ のエラーベクトル）

Classic McElieceの驚くべき点は、提案から40年以上経過し、世界中の暗号学者による激しい解読の研究に晒されてきたにもかかわらず、その本質的な脆弱性が一度も発見されていないという、圧倒的な実績にあります。PQCの中で最も「時間が証明した強固な安全性」を持っています。

さらに、暗号文のサイズが非常に小さい（わずか100〜200バイト程度）というメリットがあります。しかし、公開鍵のサイズがメガバイト（MB）単位になるという致命的な欠点が存在します。最も低いセキュリティレベル（AES-128相当）でも公開鍵が約250KB、高いレベルでは1MBを超えます。

このため、TLSハンドシェイクのように通信のたびに公開鍵をネットワーク上で送信する用途には全く適用できません。しかし、VPNの事前共有鍵の交換、ファームウェアへの公開鍵のハードコード、あるいは衛星通信など、公開鍵をシステムに事前に配置できる特殊なユースケースにおいては、その強固な安全性から極めて有望な選択肢として検討が続けられています。

10. 各PQCアルゴリズムの性能比較とトレードオフ

ここまで解説してきた主要なアルゴリズムについて、一般的なセキュリティレベル（NIST Level 2〜3相当、AES-128〜192レベル）での性能特性を以下の表にまとめました。

アルゴリズム (標準名)	カテゴリ	数学的基盤	公開鍵サイズ	秘密鍵サイズ	暗号文/署名サイズ	処理速度の傾向	主な特徴と用途
Kyber768 (ML-KEM)	KEM	Module-LWE	1,184 Bytes	2,400 Bytes	1,088 Bytes	非常に高速	鍵サイズ・速度のバランスが最高。TLS 1.3などの汎用KEM標準。
Dilithium3 (ML-DSA)	署名	Module-LWE	1,952 Bytes	4,032 Bytes	3,309 Bytes	生成・検証ともに高速	実装がシンプル。汎用的なデジタル署名標準。
FALCON-512 (FN-DSA)	署名	NTRU格子	897 Bytes	1,281 Bytes	666 Bytes	署名生成は遅め、検証は超高速	署名サイズが極小。ただし浮動小数点演算が必要。組込・IoT向け。
SPHINCS+ (SLH-DSA)	署名	ハッシュ関数	32 Bytes	64 Bytes	約 17,000 Bytes	生成が非常に遅い	数学的な破綻リスクがほぼゼロ。ルート証明書など高セキュリティ用途。
Classic McEliece	KEM	Goppa符号	約 1.04 MB	13,568 Bytes	188 Bytes	カプセル化は高速	40年の安全性実績。公開鍵が巨大。ハードコード可能な環境向け。

トレードオフの理解

PQCの世界においては、「サイズが小さく、速度が速く、数学的保証も完璧」という魔法のような単一のアルゴリズムは存在しません。

インターネットの標準 (Kyber / Dilithium): パフォーマンスのバランスが最も良く、現在のRSA/ECCからのドロップイン・リプレイスメント（そのまま置き換えること）に最も適しています。
究極の保守性 (SPHINCS+): データサイズや処理速度を犠牲にしてでも、将来的な数学的ブレイクスルーに対する絶対的な保険が欲しい場合に選択されます。
特殊環境向け (FALCON / Classic McEliece): 通信帯域が極端に狭い、あるいは事前配布が可能など、環境の制約に合わせて選ばれる特化型の武器です。

11. 実用化に向けた課題と「ハイブリッド暗号」という現実解

NISTによる標準化が完了し、FIPS規格が正式に発行されたことで、世界中のITインフラのPQC移行（PQCマイグレーション）が本格的にスタートしました。GoogleのChromeブラウザ、AppleのiMessage（PQ3プロトコル）、Cloudflareなどのネットワークプロバイダは、すでにPQCのサポートをプロトコルに実装し、実運用を開始しています。

しかし、新しい暗号アルゴリズムにいきなり完全に切り替えることには非常に高いリスクが伴います。仮にKyberなどの格子暗号に対して、数年後にある天才数学者が致命的な攻撃手法（古典コンピュータでも解けるような数学的欠陥）を発見した場合、それに依存しているシステム全体が一瞬にして丸裸になってしまいます。

この不確実性リスクを軽減するための現実的かつ推奨されるアプローチが「ハイブリッド暗号 (Hybrid Cryptography)」です。

ハイブリッド暗号では、長年の実績がある現行の古典的暗号（例：X25519などの楕円曲線暗号）と、新しいPQC（例：Kyber768）の両方を同時に使用して鍵交換を行います。それぞれのアルゴリズムで個別に共通鍵成分を生成し、最後に安全な鍵導出関数（KDF）を用いて二つの成分を混ぜ合わせ、最終的なマスターシークレットを生成します。

graph TD A["クライアント"] -->|① X25519の公開鍵 + Kyberの公開鍵を送信| B["サーバー"] B -->|② X25519の共有鍵 + Kyberのカプセル化暗号文を返信| A A --> C{"マスターシークレットの導出 (KDF)"} B --> C C -->|入力: (X25519の共通鍵) || (Kyberの共通鍵)| D["セキュアな通信鍵 (AES-256 / ChaCha20)"] D -->|"量子の脅威＆古典的な脆弱性の両方に耐性"| E["安全なハイブリッド暗号通信 (TLS 1.3)"]

これにより、「万が一量子コンピュータが実現してECCが破られてもKyberが通信を守り」、逆に「万が一Kyberに未知の数学的欠陥が見つかってもECCが通信を守る」という、堅牢な二段構えの安全性を実現できます。代表的な例として、IETFで標準化が進められている X25519MLKEM768 (旧 X25519Kyber768) ドラフトがあり、現在のWebブラウザと最先端のサーバー間の通信は、まさにこのハイブリッド方式を用いて行われています。

また、システム設計において「特定の暗号アルゴリズムに過度に依存せず、アルゴリズムが破綻した際に迅速に別のアルゴリズム（例：KyberからMcElieceへ、DilithiumからSPHINCS+へ）に切り替えられるアーキテクチャ」を構築する Crypto Agility（暗号の俊敏性） の概念が、今後のシステム開発において必須の要件となります。

12. まとめ：暗号技術の新たな地平線

量子コンピュータという人類の夢のテクノロジーは、皮肉にも私たちが長年信頼を寄せてきた「素因数分解」や「離散対数問題」という数学的防壁を打ち破る最大の脅威となりました。しかし、世界中の暗号学者たちはそれに屈することなく、格子理論、ハッシュ関数木、誤り訂正符号といったより複雑で深遠な多次元の数学的領域を開拓し、耐量子計算機暗号（PQC）という新たな防壁を築き上げました。

NISTによるFIPS 203 (ML-KEM)、FIPS 204 (ML-DSA)、FIPS 205 (SLH-DSA) の標準化完了は、ゴールではありません。これから数十年続くPQCマイグレーションという壮大な旅の第一歩に過ぎません。ソフトウェアエンジニアやシステムアーキテクトにとって、これらの新アルゴリズムがもたらす「鍵サイズの増大」や「計算コストの変化」をネットワークプロトコルやシステムにどのように最適に適応させていくかが、これからの大きな技術的課題となるでしょう。

量子コンピュータと暗号の戦いは、人類の数学的探求とテクノロジーの進化が最も激しく交差するエキサイティングな領域です。本記事を通じて、PQCの背後にある美しい数学の理論と、サイバーセキュリティの未来を形作る各アルゴリズムの驚くべきメカニズムについて、深く理解していただけたなら幸いです。

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

量子コンピュータが実用化される日：2026年の現在地

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

1. はじめに：2026年、量子コンピュータはどこまで来たのか

2026年現在、量子コンピューティングはかつての「理論上の夢」から「工学的な現実」へと決定的なシフトを遂げました。数年前まで主流であった**NISQ（Noisy Intermediate-Scale Quantum）**デバイスの限界が明確になるにつれ、世界中の研究機関とテックジャイアントは「誤り耐性量子計算（FTQC: Fault-Tolerant Quantum Computing）」の実現へと舵を切りました。

この記事では、2026年の最新のブレイクスルーを交えながら、量子コンピュータの現在地を深く掘り下げます。特に、量子エラー訂正（表面符号）、物理量子ビットと論理量子ビットの違い、トポロジカル量子計算の進展、そして超伝導・イオントラップ方式の最前線について詳解します。

2. 量子状態の基礎とフィデリティ（忠実度）

量子コンピュータの基本単位である量子ビット（Qubit）は、古典的なビット（0または1）とは異なり、0と1の重ね合わせ状態（Superposition）をとることができます。単一の量子ビットの状態は、ヒルベルト空間上のベクトルとして次のように表されます。

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

ここで、$\alpha$ と $\beta$ は複素数の確率振幅であり、以下の規格化条件を満たします。

$$ |\alpha|^2 + |\beta|^2 = 1 $$

量子計算の性能を測る上で極めて重要な指標が**フィデリティ（Fidelity）**です。理想的な量子状態 $|\psi\rangle$ と、ノイズによって劣化し混合状態となった実際の密度行列 $\rho$ との間のフィデリティ $F$ は次のように定義されます。

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

2026年の現在、2量子ビットゲート（例：CNOTゲートやCZゲート）のフィデリティは、超伝導方式で**99.99%**の壁（いわゆる「4ナイン」）を安定して超えるようになりました。これは表面符号によるエラー訂正の閾値（約99%）を大幅に上回る数値であり、実用化に向けた最大のブレイクスルーの一つです。

3. NISQ時代の限界とFTQCへのパラダイムシフト

2010年代後半から2020年代前半にかけては、エラー訂正を持たない数十〜数百量子ビットのデバイスであるNISQ（Noisy Intermediate-Scale Quantum）の時代でした。しかし、NISQには明確な限界がありました。

回路の深さ（Depth）が増すにつれてエラーが指数関数的に蓄積し、意味のある計算結果を得ることが不可能になります。回路の深さ $D$ における全体の成功確率 $P_{success}$ は、単一ゲートのフィデリティ $f$ とゲート数 $N$ に対して次のように減衰します。

$$ P_{success} \approx f^N $$

もし $f = 0.99$ で1000個のゲートを適用した場合、$0.99^{1000} \approx 4.3 \times 10^{-5}$ となり、結果はほぼランダムノイズに埋もれてしまいます。このため、2026年においては、NISQアルゴリズム（VQEやQAOAなど）の直接的なスケールアップよりも、**論理量子ビット（Logical Qubit）**の生成にリソースが集中しています。

4. 量子エラー訂正と論理量子ビット：表面符号の最前線

量子エラー訂正（QEC: Quantum Error Correction）は、複数の「物理量子ビット」をエンコードして1つの「論理量子ビット」を作り出し、エラーを検知・訂正する技術です。現在最も有望視されているのが**表面符号（Surface Code）**です。

4.1 表面符号（Surface Code）の構造

表面符号では、量子ビットを2次元の格子状に配置します。データ量子ビット（実際の情報を保持）と測定量子ビット（シンドローム測定用）が市松模様のように並びます。

graph TD A["Data Qubit (D1)"] --- B["Measure Qubit (M1)"] B --- C["Data Qubit (D2)"] C --- D["Measure Qubit (M2)"] D --- E["Data Qubit (D3)"] B --- F["Data Qubit (D4)"] D --- G["Data Qubit (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

スタビライザー演算子 $S_x$ と $S_z$ を用いて、ビット反転（Xエラー）と位相反転（Zエラー）を絶えず監視します。

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

2026年の重大な進展は、「ブレイクイーブン点（Break-even point）」を完全に突破したことです。すなわち、エラー訂正を行うための余分な回路が引き起こすノイズよりも、エラー訂正によって取り除かれるノイズの方が大きくなり、論理量子ビットの寿命が物理量子ビットの寿命を何桁も上回るようになりました。

4.2 量子エラー訂正のサイクル

エラー訂正は継続的なフィードバックループとして機能します。

sequenceDiagram participant D as "Data Qubits" participant M as "Ancilla/Measure Qubits" participant C as "Classical Controller" loop "Syndrome Extraction Cycle (approx 1 microsec)" D->>M: "Entangle (CNOT/CZ)" M->>C: "Measure State (Syndrome)" C->>C: "Decode Syndrome (e.g. Minimum Weight Perfect Matching)" C-->>D: "Apply Pauli Correction (if necessary)" end

現在では、この古典的なデコード処理（シンドロームの解析）をFPGAや専用ASICでナノ秒単位で実行する技術が確立され、リアルタイムでのエラー訂正が実用段階に入っています。

5. ハードウェアアーキテクチャの進化（2026年版）

2026年における量子ハードウェアは、主に「超伝導方式」「イオントラップ方式」「トポロジカル方式」の3つの軸で進化しています。

5.1 超伝導量子ビットの集積化

超伝導方式は、IBMやGoogleがリードする分野であり、ジョセフソン接合を用いたトランズモン（Transmon）量子ビットが主流です。2026年には、単一チップ上に数千から一万の物理量子ビットを集積するメガチップが実現しました。

特筆すべきは、**モジュール間量子通信（Quantum Interconnects）**の確立です。マイクロ波光子を用いたチップ間の量子テレポーテーションが商用レベルで実装され、単一の希釈冷凍機のサイズ制限を回避できるようになりました。

5.2 イオントラップの2次元スケーリングと光インターコネクト

イオントラップ方式（QuantinuumやIonQなどが主導）では、真空中に浮遊するイオンの内部エネルギー状態を量子ビットとして用います。超伝導方式と比較して、T1/T2コヒーレンス時間が極めて長く、全結合（All-to-All Connectivity）が可能という利点があります。

2026年のブレイクスルーは、QCCD（Quantum Charge Coupled Device）アーキテクチャの2次元化と、フォトニックインターコネクトを用いたマルチトラップ間の高速エンタングルメント生成です。これにより、イオントラップの弱点であった「ゲート速度の遅さ」と「スケーラビリティ」が劇的に改善されました。

5.3 トポロジカル量子計算：エニオンの制御

長らく理論上の存在とされてきたトポロジカル量子計算が、2026年に遂に実験的な実証のフェーズに入りました。Microsoftなどが推し進めるこの方式は、「マヨラナゼロモード（Majorana Zero Modes）」と呼ばれる非可換エニオン（Non-Abelian Anyons）を用います。

エニオンの粒子の位置を入れ替える「ブレイディング（Braiding）」という操作によって量子ゲートを実行します。

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

ここで $B_{ij}$ はブレイディング演算子です。トポロジカル方式は、情報の保存が粒子の局所的な状態ではなく、全体の「結び目」のトポロジーに依存するため、環境ノイズに対して本質的に耐性（ハードウェアレベルでのエラー耐性）を持っています。2026年に世界で初めて高忠実度なトポロジカル論理量子ビットの生成が確認され、FTQCへの強力なショートカットとして注目を集めています。

6. 実用化に向けたロードマップと展望

量子コンピュータが「化学計算」「材料科学」「金融モデリング」などで古典コンピュータ（スーパーコンピュータ）を圧倒する**量子超越性（Quantum Advantage）**を真に発揮するためには、数千の論理量子ビットが必要です。

gantt title "Quantum Computing Roadmap (Revised 2026)" dateFormat YYYY axisFormat %Y section "NISQ Era" "Noisy Qubits (<1000)" :done, 2018, 2024 section "Early FTQC" "Break-even Point Demonstration" :done, 2024, 2026 "Hundreds of Logical Qubits" :active, 2026, 2028 section "Full-Scale FTQC" "1000+ Logical Qubits (Commercial App)" : 2028, 2030 "Universal Fault-Tolerant Quantum Computer" : 2030, 2035

6.1 現在直面している課題と未来

2026年時点での最大の課題は、極低温を維持するための巨大なクライオスタット（希釈冷凍機）の冷却能力と、室温の制御装置と極低温の量子チップを繋ぐ配線（I/Oボトルネック）です。これに対して、極低温環境で動作するCMOS（Cryo-CMOS）コントローラチップの開発が急ピッチで進んでいます。

結論

2026年は、量子コンピュータの歴史において「論理量子ビットのスケールアップ元年」として記録されるでしょう。エラー訂正アルゴリズムの実証、ハードウェアのモジュール化、そしてトポロジカルアプローチの急進展により、「実用化される日」はもはや遠い未来の話ではなく、今後数年以内の具体的なマイルストーンとして見据えることができるようになりました。量子アルゴリズムの開発者や企業にとって、今こそ量子ネイティブな問題解決へと本格的に投資すべきタイミングと言えます。

この記事は2026年時点の最新の量子コンピューティング研究論文および業界動向に基づいて執筆されています。