量子情報理論の基本：ホレボー限界

$$
\def\bra#1{\mathinner{\left\langle{#1}\right|}}
\def\ket#1{\mathinner{\left|{#1}\right\rangle}}
\def\braket#1#2{\mathinner{\left\langle{#1}\middle|#2\right\rangle}}
$$

## はじめに

[前回の記事](https://qiita.com/SamN/items/a0582e3aa9a888afe686)で「量子エントロピー」の基本が理解できました。ということで、次に「量子暗号」などの応用技術に進出とも思ったのですが、もう少しおさえておくべき基本事項がありそうなので、しばらくは基本のお勉強を続けます（と言っているとキリがないのですが、面白い話題がたくさんあるので仕方ありません）。さて、今回は、「ホレボー限界」を取り上げます。その量子情報通信における意味合いや定義について説明した後、量子計算シミュレータ[qlazy](https://github.com/samn33/qlazy)を使って、その「限界」を実感してみたいと思います。

参考にさせていただいたのは、以下の文献です。

1. [ニールセン、チャン「量子コンピュータと量子通信（３）」オーム社（2005年）](https://www.ohmsha.co.jp/book/9784274200090/)
2. [石坂、小川、河内、木村、林「量子情報科学入門」共立出版（2012年）](https://www.kyoritsu-pub.co.jp/bookdetail/9784320122994)
3. [富田「量子情報工学」森北出版（2017年）](https://www.morikita.co.jp/books/book/3109)

## ホレボー限界とは

量子ビットは古典ビットと違って、０と１の重ね合わせ状態を表現できるのでした。つまり、無限の自由度が一つの量子ビットの中にあるということなので、原理的にはそこに無限の情報を仕込むことができそうです。とすると、この量子ビットを使えば、ものすごい伝送容量をもった通信が実現できそうな気がしてきます。例えば、アリスは自分が持っている一個の量子ビットに何らかの方法で無限長のビットを書き込み、ボブに伝送します[^1]。ボブは、受け取った量子ビットから意味のある情報を取り出すために、測定をしないといけないのですが、一般化測定（POVM測定）を考えれば、任意個数の測定結果を得るようにできます。仕込まれた無限長の情報を正しく取り出せるように、うまいPOVMが設計できれば、夢の情報通信が実現できるはずです！

[^1]: 例えば、量子状態$\ket{\psi}=a \ket{0} + b \ket{1}$の係数$a$または係数$b$、あるいは両方に無限桁（実際にはとても長い桁）のビット列を乗せます。具体的には、伝送前に何らかの回転ゲートをかける（例えば、光子であれば何らかの角度で偏光させる）操作を行って、その角度にビット列を仕込めば良いです。

この話、本当でしょうか？

世の中、そんなに甘くはありません。実は、取り出せる情報量には限界があります。その限界のことを「ホレボー限界」と言います。悲しい結論を先に言うと、その限界、つまり、１量子ビットから取り出せる情報量の上限は、実は１ビットしかないのです！

理論的には、以下のように記述されます[^2]。

[^2]: [量子情報工学](https://www.morikita.co.jp/books/book/3109)のp.145に「定理」として記載されています。

「アリスの情報源はシンボル$\\{ X_i \\},\space i=1,\cdots,n$を確率$p_i$で出力する。このシンボル系列$X$に従って$\rho_X$で表わされる量子状態$Q$をつくり、ボブに送る。ボブは送られてきた状態に対してPOVM $\\{ E_Y\\}=\\{ E_{1},\cdots,E_{m} \\}$を行って古典情報$Y$を得る。このとき、$X$と$Y$の間の相互情報量$I(X:Y)$の上限は次のように与えられる。

```math
I(X:Y) \leq S(\rho) - \sum_{i=1}^{n} p_i S(\rho_i)  \tag{1}
```

ただし、

```math
\rho = \sum_{i=1}^{n} p_i \rho_i  \tag{2}
```

である。この上限のことを「ホレボー限界」と言う。」

では、証明してみます[^3]。

[^3]: [量子情報工学](https://www.morikita.co.jp/books/book/3109)の証明が非常にわかりやすかったので、それをほぼなぞっているだけになっています。

【証明】

情報源であるアリスの系を系A、発生した情報に応じて用意する量子状態の系を系Q、ボブが受け取った量子状態を測定する測定器の系を系Bとします。系Aの情報源から、古典情報$\\{ X_i \\}$が確率$\\{ p_i \\}$で発生しますが、$X_i$はオブザーバブル$X$の固有状態$\ket{i}^A$に対する固有値とみなせるので、$X_i$が発生したというのは、量子状態$\ket{i}^{A} \bra{i}^{A}$が発生したのと同じことです。次に、発生した$X_i$に応じて、量子状態$\rho_i$を割り当てることにします。初期的には、ボブのもとには何も来ていないので$\ket{0}^{B} \bra{0}^{B}$とすると、全体系$\rho^{total}$の初期状態は、

```math
\rho^{total} = \sum_{i} p_i \ket{i}^{A} \bra{i}^{A} \otimes \rho_i \otimes \ket{0}^{B} \bra{0}^{B}  \tag{3}
```

と書けます。ここで、ボブが測定します。この測定に対応したCPTPマップを$\Gamma$とし、測定結果$y$を得るKraus演算子を$M_y$とすると、

```math
\Gamma(\rho^{total}) = \sum_{i} p_i \ket{i}^{A} \bra{i}^{A} \otimes (\sum_{y} M_y \rho_i M_y^{\dagger} \otimes \ket{y}^{B} \bra{y}^{B})  \tag{4}
```

となります。

初期状態における系Aと系Qの相互情報量$I(A:Q)$は、それらと独立な積状態になっている系Bを追加しても変わらないので、

```math
I(A:Q) = I(A:Q,B)  \tag{5}
```

です。測定後の系を各々$A^{\prime},Q^{\prime},B^{\prime}$とすると、量子チャンネルによって相互情報量は減少する[^4]ので、

[^4]: [前回の記事](https://qiita.com/SamN/items/a0582e3aa9a888afe686)の「性質(13)」を参照。

```math
I(A:Q,B) \geq I(A^{\prime}:Q^{\prime},B^{\prime})  \tag{6}
```

が成り立ちます。測定後の系$Q^{\prime}$を捨てると相互情報量は減少する[^5]ので

[^5]: [前回の記事](https://qiita.com/SamN/items/a0582e3aa9a888afe686)の「性質(12)」を参照。

```math
I(A^{\prime}:Q^{\prime},B^{\prime}) \geq I(A^{\prime}:B^{\prime})  \tag{7}
```

となります。式(5)(6)(7)を合わせると、

```math
I(A^{\prime}:B^{\prime}) \leq I(A:Q)  \tag{8}
```

が成り立ちます。ここで、$I(A^{\prime}:B^{\prime})$は古典的な相互情報量なので、$I(X:Y)$と書いても良いです。とすると、式(8)は、

```math
I(X:Y) \leq I(A:Q)  \tag{9}
```

となります。$I(A:Q)$は、

```math
\begin{align}
I(A:Q) &= S(A) + S(Q) - S(A,Q) \\
&= H(A) + S(\rho) - S(A,Q)  \tag{10}
\end{align}
```

のように書けるので、式(9)に代入すると、

```math
I(X:Y) \leq H(A) + S(\rho) - S(A,Q)  \tag{11}
```

となります。

ここで、$S(A,Q)$について考えます。いま、$\rho_i$をスペクトル分解して、

```math
\rho_i = \sum_{j} q_{i}^{j} \ket{e_{i}^{j}} \bra{e_{i}^{j}}  \tag{12}
```

のようにできるとします。そうすると、$S(A,Q)$は、

```math
\begin{align}
S(A,Q) &= S(Tr_{B}(\rho^{total})) \\
&= -Tr((\sum_{i,j} p_i \ket{i}^{A} \bra{i}^{A} \otimes q_{i}^{j} \ket{e_{i}^{j}} \bra{e_{i}^{j}}) \log(\sum_{i,j} p_i \ket{i}^{A} \bra{i}^{A} \otimes q_{i}^{j} \ket{e_{i}^{j}} \bra{e_{i}^{j}})) \\
&= - \sum_{i,j} p_{i} q_{i}^{j} \log(p_{i} q_{i}^{j}) \\
&= - \sum_{i} p_{i} \log p_{i} - \sum_{i} p_i \sum_{j} q_{i}^{j} \log q_{i}^{j} \\
&= H(A) + \sum_{i} p_{i} S(\rho_{i})  \tag{13}
\end{align}
```

と計算できます。これを、式(11)に代入すると、

```math
I(X:Y) \leq S(\rho) - \sum_{i} p_{i} S(\rho_{i})  \tag{14}
```

が成り立ちます。（証明終）

ここで、式(1)の右辺の上限、

```math
\chi \equiv S(\rho) - \sum_{i} p_i S(\rho_i)  \tag{15}
```

のことを「ホレボー情報量(holevo quantity)」と言います。このホレボー情報量は、量子相対エントロピーを用いて、

```math
\chi = \sum_{i} p_i S(\rho_i||\rho)  \tag{16}
```

のように表すこともできます。それは、

```math
\begin{align}
\sum_{i} p_{i} S(\rho_i || \rho) &= \sum_{i} p_{i} Tr(\rho_{i} \log \rho_{i} - \rho_{i} \log \rho) \\
&= \sum_{i} p_{i} Tr(\rho_{i} \log \rho_{i}) - \sum_{i} p_{i} Tr(\rho_{i} \log \rho) \\
&= - \sum_{i} p_{i} S(\rho_{i}) - Tr(\sum_{i} p_{i} \rho_{i} \log \rho) \\
&= S(\rho) - \sum_{i} p_{i} S(\rho_{i})  \tag{17}
\end{align}
```

であることからわかります。

さて、ボブが受け取れる情報量（すなわち、この通信チャネルで伝送できる情報量）の上限が式(15)のように与えられたわけですが、この限界について、もう少し具体例をあげて、吟味してみます。

いま、アリスは、1個の量子ビットに対して、M種類の量子状態$\\{ \ket{\phi_1},\ket{\phi_2},\cdots,\ket{\phi_M}\\}$のいずれかを任意にセットして、ボブに向けて発射できる装置をもっているものとします。アリスは、この装置を使ってM種類のアルファベットからなるメッセージをボブに対して送ります。さて、ボブはアリスから、最大どれだけの情報量を受け取れるでしょうか？まさに、いま説明した「ホレボー情報量」を計算すれば良いです。やってみます。

```math
\rho_i = \ket{\phi_i} \bra{\phi_i}  \tag{18}
```

とすると、アリスが発生させる量子状態は全体として、

```math
\rho = \sum_{i}^{M} p_i \ket{\phi_i} \bra{\phi_i}  \tag{19}
```

となります。これを使って、ホレボー情報量を計算します。式(18)は純粋状態なので、式(15)の（右辺の）第２項はゼロです。したがって、

```math
\chi = S(\rho)  \tag{20}
```

となります。ここで、$\rho$は1量子ビット（ヒルベルト空間の次元は2）に対する密度演算子なので、エントロピーは$\log 2 = 1$を超えることはありません。ということで、せっかくアリスが頑張ってボブに送ろうとした大事なメッセージも、ボブにとってみると単なる２進数（＝1ビット）の系列としてしか認識できません、ということになります。これは、ボブの努力が足りないからではなく、ホレボー限界のせいです。ボブには、どう頑張っても（POVM測定をいかに工夫しても）、超えられない壁があるということです[^6]。

[^6]: むしろ、1量子ビットしか用意できない、アリスがこの壁をつくっているとも言えますが、内緒です（笑）。

では、アリスの装置が進化して、2量子ビット同時発射ができるようになったとするとどうでしょう。この場合、式(20)に示されている$S(\rho)$の値が2になりますので、ボブは頑張れば2ビットの情報を受け取れるようになります。さらに、N量子ビット同時発射できるようになると、ボブはNビット受け取れるようになります。

というわけで、1量子ビットに無限長のビット列を仕込んで伝送するという「夢の情報通信」は到底不可能であるという、現実がここに明確に提示されたということになります[^7]（無念！）。

[^7]: [ニールセン・チャン](https://www.ohmsha.co.jp/book/9784274200090/)の「演習問題12.3」は、「n個のｑビットを使ってnビット以上の古典情報を伝送することはできないことをHolevoの限界を使って論じよ」となっていますので、この解答がこれでできたことになると思います。


## 量子通信チャネルの具体例

さて、それでは、この「限界」をシミュレータを使って実感してみたいのですが、それにあたり何か具体例がほしいと思っていたところ、ちょうど、[ニールセン・チャン](https://www.ohmsha.co.jp/book/9784274200090/)の「演習問題12.4」に良い題材があったので、そこに記述されている量子通信チャネルでやってみます。どういうものかを以下に説明します。

送信者であるアリスが用意できる1量子ビットの量子状態は、

```math
\begin{align}
\ket{X_1} &= \ket{0} \\
\ket{X_2} &= \frac{1}{3} (\ket{0} + \sqrt{2} \ket{1}) \\
\ket{X_3} &= \frac{1}{3} (\ket{0} + \sqrt{2} e^{2\pi i/3} \ket{1}) \\
\ket{X_4} &= \frac{1}{3} (\ket{0} + \sqrt{2} e^{4\pi i/3} \ket{1}) \tag{21}
\end{align}
```

という4種類であり、送りたい文字列（古典情報）に応じてこのどれかを選択して、次々にボブに向けて発射します。それを受け取ったボブは何らかのPOVM測定することで古典情報を得るという量子通信チャネルです。この量子通信の性質を評価するため、一旦、アリスには、ランダムにこの4つを選択して発射してもらうことにします。先程の議論からすると、量子ビットは1個なので最大で1ビットの伝送が可能です。つまり、アリスが発射する状態の密度演算子から、ホレボー情報量を計算すると、1になります（なるはずです）。しかし、実際には適切なPOVMをボブが設計しないと、取り出せる情報（＝相互情報量）は、1ビットになりません。[ニールセン・チャン](https://www.ohmsha.co.jp/book/9784274200090/)には、およそ「0.415ビットを達成するPOVMは知られている」と書いてあります。そのときのPOVMは何でしょうか？というのが、この演習問題の問いです。

というわけで、ボブの立場になって、とりあえず「0.415」を目標にPOVMを設計してみましょう。

まず、簡単に思いつくのは、式(21)の4つの基底を使った射影演算です。つまり、

【POVM #1】

```math
\begin{align}
E_1 &= \frac{1}{2} \ket{X_1} \bra{X_1} \\
E_2 &= \frac{1}{2} \ket{X_2} \bra{X_2} \\
E_3 &= \frac{1}{2} \ket{X_3} \bra{X_3} \\
E_4 &= \frac{1}{2} \ket{X_4} \bra{X_4} \tag{22}
\end{align}
```

です。ここで$\sum_{i} E_i = I$になるように係数$1/2$をすべてのPOVMにかけました。

次に思いつくパターンは、式(21)の各基底と直交する基底、

```math
\begin{align}
\ket{\tilde{X}_1} &= \ket{1} \\
\ket{\tilde{X}_2} &= \sqrt{\frac{1}{3}} (\sqrt{2} \ket{0} - \ket{1}) \\
\ket{\tilde{X}_3} &= \sqrt{\frac{1}{3}} (\sqrt{2} \ket{0} - e^{2 \pi i/3} \ket{1}) \\
\ket{\tilde{X}_4} &= \sqrt{\frac{1}{3}} (\sqrt{2} \ket{0} - e^{4 \pi i/3} \ket{1}) \tag{23}
\end{align}
```

を使った射影演算です。つまり、

【POVM #2】

```math
\begin{align}
\tilde{E}_1 &= \frac{1}{2} \ket{\tilde{X}_1} \bra{\tilde{X}_1} \\
\tilde{E}_2 &= \frac{1}{2} \ket{\tilde{X}_2} \bra{\tilde{X}_2} \\
\tilde{E}_3 &= \frac{1}{2} \ket{\tilde{X}_3} \bra{\tilde{X}_3} \\
\tilde{E}_4 &= \frac{1}{2} \ket{\tilde{X}_4} \bra{\tilde{X}_4} \tag{24}
\end{align}
```

です。この２パターンでシミュレーションし、ホレボー情報量と相互情報量が、各々どうなるかを確認してみます。


## シミュレータで確認

全体のPythonコードは以下です。

【2021.9.5追記】[qlazy](https://github.com/samn33/qlazy)最新版でのソースコードは[ここ](https://github.com/samn33/qlazy/blob/master/example/py/Holevo)に置いてあります。

```Python
import random
import cmath
import numpy as np
import pandas as pd
from qlazypy import QState, DensOp

MIN_DOUBLE = 0.000001

def classical_joint_entropy(A,B):

    code_num_A = max(A) + 1
    code_num_B = max(B) + 1

    prob = np.zeros((code_num_A,code_num_B))
    for i in range(len(A)):
        prob[A[i]][B[i]] += 1
    prob = prob / sum(map(sum, prob))

    ent = 0.0
    for i in range(code_num_A):
        for j in range(code_num_B):
            if abs(prob[i][j]) < MIN_DOUBLE:
                ent -= 0.0
            else:
                ent -= prob[i][j] * np.log2(prob[i][j])

    return ent
    
def classical_entropy(A):

    code_num = max(A) + 1

    prob = np.zeros(code_num)
    for a in A:
        prob[a] += 1.0
    prob = prob / sum(prob)

    ent = 0.0
    for p in prob:
        if abs(p) < MIN_DOUBLE:
            ent -= 0.0
        else:
            ent -= p * np.log2(p)

    return ent

def classical_mutual_information(A,B):

    ent_A = classical_entropy(A)
    ent_B = classical_entropy(B)
    ent_AB = classical_joint_entropy(A,B)

    return ent_A + ent_B - ent_AB
    
def holevo_quantity(X,de):

    samp_num = len(X)
    code_num = len(de)

    prob = np.zeros(code_num)
    for x in X:
        prob[x] += 1.0
    prob = prob / sum(prob)
    
    de_total = DensOp.mix(densop=de, prob=prob)

    holevo = de_total.entropy()
    for i in range(code_num):
        holevo -= prob[i]*de[i].entropy()

    de_total.free()
    
    return holevo

def transmit(X,de,povm):

    samp_num = len(X)
    dim_X = len(de)
    dim_Y = len(povm)

    Y = np.array([0]*samp_num)
    
    prob_list = [None]*len(X)
    for i in range(samp_num):
        prob_list[i] = de[X[i]].probability(povm=povm)
        r = random.random()
        p = 0.0
        mes = dim_Y - 1
        for k in range(dim_Y-1):
            p += prob_list[i][k]
            if r < p:
                mes = k
                break
        Y[i] = mes
        
    return Y

def make_densop(basis):

    qs = [QState(vector=b) for b in basis]
    de = [DensOp(qstate=[q], prob=[1.0]) for q in qs]

    for n in range(len(qs)):
        qs[n].free()
    
    return de
    
def make_povm(vec):

    return [np.outer(v,v.conjugate())/2.0 for v in vec]

def random_sample(code_num,samp_num):

    return np.array([random.randint(0,code_num-1) for _ in range(samp_num)])

if __name__ == '__main__':

    SQRT1      = cmath.sqrt(1/3)
    SQRT2      = cmath.sqrt(2/3)
    EXT2       = cmath.exp(2*cmath.pi*1j/3)
    EXT4       = cmath.exp(4*cmath.pi*1j/3)

    basis      = [np.array([1.0, 0.0]),
                  np.array([SQRT1, SQRT2]),
                  np.array([SQRT1, SQRT2*EXT2]),
                  np.array([SQRT1, SQRT2*EXT4])]
    
    basis_orth = [np.array([0.0, 1.0]),
                  np.array([SQRT2, -SQRT1]),
                  np.array([SQRT2, -SQRT1*EXT2]),
                  np.array([SQRT2, -SQRT1*EXT4])]

    de = make_densop(basis)

    code_num = 4
    samp_num = 100
    trial = 100

    povm_name  = ['#1','#2']
    povm_basis = [basis, basis_orth]
    
    for b in povm_basis:

        povm = make_povm(b)
    
        mutual = []
        holevo = []
        for _ in range(trial):
    
            X = random_sample(code_num,samp_num)
            Y = transmit(X, de, povm)

            mutual.append(classical_mutual_information(X,Y))
            holevo.append(holevo_quantity(X,de))

        df = pd.DataFrame({'holevo quantity':holevo,'mutual information':mutual})
        holevo_mean = df['holevo quantity'].mean()
        holevo_std  = df['holevo quantity'].std()
        mutual_mean = df['mutual information'].mean()
        mutual_std  = df['mutual information'].std()

        print("== povm: {:} ==".format(povm_name.pop(0)))
        print("[holevo quantity]")
        print("- mean = {0:.4f} (std = {1:.4f})".format(holevo_mean, holevo_std))
        print("[mutual information]")
        print("- mean = {0:.4f} (std = {1:.4f})".format(mutual_mean, mutual_std))
        print()
        
    for n in range(len(de)):
        de[n].free()
```

何をやっているか、簡単に説明します。main処理部を見てください。まず、最初の4行は、後の計算の都合上、数値定数を変数SQRT1、SQRT2、EXT2、EXT4にセットしているだけです。

変数basisと変数basis_orthは、POVM #1,#2をつくるための基底です。つまり、式(21)と式(23)の基底をここで定めています。

basisは送信したい符号を割り当てるための量子状態でもありますので、

```Python
de = make_densop(basis)
```

で、その量子状態に対応した密度演算子のリストをつくっています。

```Python
code_num = 4
samp_num = 100
trial = 100
```

code_numは符号の種類数（今回は4）、samp_numはランダムに生成する符号＝データの数、trialは何度も試行して平均とか標準偏差を得るための試行数を表しています。

```Python
povm_name  = ['#1','#2']
povm_basis = [basis, basis_orth]

for b in povm_basis:

    povm = make_povm(b)
    ...
```

で、外側のforループ（POVM #1,#2）を回します。make_povmは、基底からPOVMを作成する関数です。

内側のforループは、

```Python
mutual = []
holevo = []
for _ in range(trial):

    X = random_sample(code_num,samp_num)
    Y = transmit(X, de, povm)

    mutual.append(classical_mutual_information(X,Y))
    holevo.append(holevo_quantity(X,de))
    ...
```

で、繰り返し試行するためのものです（今回は100回）。

関数random_sampleで、ランダムな符号（データ）系列を作成し、関数transmitで伝送をシミュレーションします。関数内部でPOVM測定を模擬実行して、データ系列を取り出し、出力しています。関数classical_mutual_informationで、入力データと出力データから相互情報量を計算します。関数holevo_quantityで、入力データと密度演算子リストからホレボー情報量を計算します。これで試行回数分の相互情報量とホレボー情報量が得られます。後は、pandasを使って、各々の平均値と標準偏差を計算しています。プログラムはだいたい以上です。

さて、実行結果ですが、以下のようになりました。

```
== povm: #1 ==
[holevo quantity]
- mean = 0.9921 (std = 0.0066)
[mutual information]
- mean = 0.2714 (std = 0.0748)

== povm: #2 ==
[holevo quantity]
- mean = 0.9923 (std = 0.0057)
[mutual information]
- mean = 0.4547 (std = 0.0244)
```

ここで、meanは平均値、stdは標準偏差を表します。

まず、ホレボー情報量(holevo quantity)について見てみます。ホレボー情報量は、情報源の確率分布と符号化に使う量子状態セットが決まれば決まるという定義だったので、POVMをどう選ぼうと同じ値になります。プログラムではrandom関数でランダムに発生させる実装にしており、正確に均等の確率分布にならないという影響で、1から少し外れた値になっています。が、限界値1が確認できました。

一方、相互情報量(mutual information)はどうかと言うと、これは仮想的にランダム発生させた情報源を量子ビットで符号化し、ボブがPOVM測定をする想定なので、POVMによって結果が大きく変わります。見ての通り「POVM #2」の方が良い（より1に近い）結果です。[ニールセン・チャン](https://www.ohmsha.co.jp/book/9784274200090/)の目標値「0.415」にも近いです。というか、それを超えていますが....。これはrandom関数を使っていて、かつ、サンプル数や試行数をそれほど大きな値にしていないことからくる誤差と思われます。いずれにせよ、この「POVM #2」が、正解のような気がします。

ここで疑問が一つ。平行か直交かの違いはありますが、同じようなPOVMを用意したのに、なぜこんなに差が出たのでしょうか？「POVM #1」の方は、例えばボブの測定結果が「1」だったとき、アリスの符号が「1」だった可能性がもっとも高いですが、ある確率で「2」や「3」や「4」だったという場合も含まれています。それに対し、「POVM #2」の場合は、ボブの測定結果が「1」だった場合、アリスの符号が「1」だったという可能性は消えます。「2」か「3」か「4」のどれかのはずです。つまり、「POVM #2」の方が、ボブが受け取る情報の不確実性は小さくなります。このことが両者の差に効いているのだと思います[^8]。

[^8]: 一般化測定を説明した[以前の記事](https://qiita.com/SamN/items/4f3e3d12e307e084b2f2)で、[量子情報工学](https://www.morikita.co.jp/books/book/3109)に掲載されていた例に従いPOVM測定のシミュレーションをやりましたが、その際、伝送する量子ビットと直交する基底を使ってPOVMを構成すると、「誤りのない判別(unambiguous state discrimination)」が実現できることがわかりました。それと関係する話だと思います。

とは言え、およそ「0.415」という数値は限界値の1と比べると、あまりにも小さい感じがします。「ニールセン・チャン」の演習問題には、「さらによくHolevoの限界を達成する測定を構築することができるであろうか？」とあります。今後の課題とさせてください。


## 理論計算で確認

さて、話をこれで終わらせても良いのですが、「POVM #2」が本当に相互情報量「0.415」を与えるものなのか、理論的にまだ証明できていないです。シミュレーションにより実験的にそれっぽいということがわかっただけです。しかも、結構な誤差です（小数点以下２桁目ですでに外れています）。そこで、理論計算（というか手計算）で、相互情報量がこの値になることを確認してみたいと思います。

相互情報量の定義は、

```math
\begin{align}
I(X:Y) &= H(X) + H(Y) - H(X,Y) \\
&= \sum_{i,j} p(X_i, Y_j) \log \frac{p(X_i,Y_j)}{p(X_i) p(Y_j)} \tag{25}
\end{align}
```

でした。ということで、$p(X_i,Y_j)$がわかれば、あとは$p(X_i),p(Y_j)$は各確率変数で周辺化すれば良いので、これで相互情報量は計算できます。$p(X_i,Y_j)$というのは、情報源から$X_i$が発生して、受信側で$Y_j$を復号する同時確率分布です。いま$i$と$j$は各々1から4までの4パターンなので、計16個の値がわかれば良いです。

では、やってみます。$p(X_i,Y_j)$をいちいち書くのが面倒なので$p_{ij} \equiv p(X_i,Y_j)$としておきます。

```math
\begin{align}
p_{ij} &= Tr(\tilde{E}_{j} \rho_{i}) \\
&= Tr(\frac{1}{2} \ket{\tilde{X}_j} \braket{\tilde{X}_j}{X_i} \bra{X_i}) \\
&= \frac{1}{2} \braket{\tilde{X}_j}{X_i} Tr(\ket{\tilde{X}_j}  \bra{X_i}) \tag{26}
\end{align}
```

これに、式(21)と式(23)を代入して地道に計算します。同時確率分布としての正規化は、これではできていないはずなので、最後に総和が1になるように正規化するようにします。

まず、$i=1$の場合です。

```math
p_{11} = 0, \space p_{12} = \frac{1}{3}, \space p_{13} = \frac{1}{3}, \space p_{14} = \frac{1}{3}  \tag{27}
```

同様に、$i=2$の場合は、

```math
p_{21} = \frac{1}{3}, \space p_{22} = 0, \space p_{23} = \frac{2}{9} (1-\cos \frac{2\pi}{3}), \space p_{24} = \frac{2}{9} (1-\cos \frac{4\pi}{3}) \tag{28}
```

$i=3$の場合は、

```math
p_{31} = \frac{1}{3}, \space p_{32} = \frac{2}{9} (1-\cos \frac{2\pi}{3}), \space p_{33} = 0, \space p_{34} = \frac{2}{9} (1-\cos \frac{2\pi}{3}) \tag{29}
```

$i=4$の場合は、

```math
p_{41} = \frac{1}{3}, \space p_{42} = \frac{2}{9} (1-\cos \frac{4\pi}{3}), \space p_{43} = \frac{2}{9} (1-\cos \frac{2\pi}{3}), \space p_{44} = 0 \tag{30}
```

と計算できます。ここで、

```math
\begin{align}
\frac{2}{9} (1-\cos \frac{2\pi}{3}) &= \frac{2}{9} (1 - (-\frac{1}{2})) = \frac{1}{3} \\
\frac{2}{9} (1-\cos \frac{4\pi}{3}) &= \frac{2}{9} (1 - (-\frac{1}{2})) = \frac{1}{3} \tag{31}
\end{align}
```

ですので、$p_{ij}$は、

```math
\begin{pmatrix}
p_{11} & p_{12} & p_{13} & p_{14} \\
p_{21} & p_{22} & p_{23} & p_{24} \\
p_{31} & p_{32} & p_{33} & p_{34} \\
p_{41} & p_{42} & p_{43} & p_{44}
\end{pmatrix}
= \frac{1}{12}
\begin{pmatrix}
0 & 1 & 1 & 1 \\
1 & 0 & 1 & 1 \\
1 & 1 & 0 & 1 \\
1 & 1 & 1 & 0
\end{pmatrix}  \tag{32}
```

という具合に、とても簡単な形になります（ここで、同時確率分布の総和が1になるように正規化しました）。

```math
\begin{align}
& p(X_i,Y_j) = p_{ij} \\
\\
& p(X_i) = \sum_{j} p_{ij} \\
& p(Y_j) = \sum_{i} p_{ij} \tag{33}
\end{align}
```

として、式(25)に代入すると、

```math
I(X:Y) = 12 \times \frac{1}{12} \log \frac{\frac{1}{12}}{\frac{1}{4} \times \frac{1}{4}} = \log \frac{4}{3} = 2 - \log 3 = 0.415037\cdots  \tag{34}
```

となり、確かに相互情報量は「0.415」になるということが確認できました。めでたし、めでたし。


## おわりに

量子エントロピーの基礎知識のおかげで、量子情報通信の話も結構すんなり理解できた気がします（まだほんの触りの部分だからかもしれませんが）。この調子でズンズン行きますよ！

でも、次回の話題は例によって未定です。


以上