Skip to main content
IBM Quantum Platform

量子鍵分配

このQiskit in Classroomsモジュールでは、以下のパッケージがインストールされた Python 環境が必要です：

  • qiskit v2.1.0 または新しい
  • qiskit-ibm-runtime v0.40.1 または新しい
  • qiskit-aer v0.17.0 または新しい
  • qiskit.visualization
  • numpy
  • pylatexenc

上記のパッケージをセットアップしてインストールするには、 Qiskitのインストールガイドをご覧ください。 実際の量子コンピュータでジョブを実行するには、 IBM Quantum® のアカウントを設定する必要があります。 IBM Cloud アカウントの設定ガイドの手順に従ってください。

このモジュールはテストされ、5秒のQPU時間を使用した。 これはあくまでも目安である。 実際の使用方法は異なる場合があります。

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

ケイティ博士（ McCormick ）によるモジュールのウォークスルーを以下でご覧いただくか、 こちらをクリックして YouTube でご覧ください。

はじめにおよび動機

情報を暗号化・復号化する方法は無限にあり、文字通り何千通りもの方法が研究されてきた。 ここでは、このプロトコルの量子的な部分に焦点を当てるため、「単純置換」と呼ばれる非常に初期の、非常に単純な暗号化方法に限定する。 量子の部分は、比較的少ない変更で他の多くのプロトコルに適応できるだろう。

単純な置換

単純な置き換え暗号化とは、ある文字や数字が別の文字や数字に置き換えられるもので、メッセージ内の文字や数字と暗号化されたシーケンスで使われる文字や数字が1対1に対応するようなものである。 このようなポップカルチャーの例として、クリプトクオートやクリプトグラム・パズルがある。このパズルでは、引用文やフレーズが単純な置き換えを使って暗号化されており、プレイヤーはそれを解読するのが仕事である。 これらの問題は、十分な長さがあれば簡単に解決できる。 例を考えてみよう：

r wvxrwvw gszg r'w yvggvi nzpv gsrh kivggb OLMT gszg dzb, kvlkov droo szev zm vzhrvi grnv hloermt rg. R SLKV R NZWV RG HRNKOV VMLFTS

これらを手作業で解く人は、たいてい元のメッセージの言語構造に精通したトリックを使う。 たとえば英語では、暗号化された "R "のような一文字の単語は "a "と "I "しかない。 例えば "KIVGGB "で暗号化された二重文字は、ある特定の値しか取ることができない。 例えば、「GSZG」のパターンに当てはまる最も一般的な単語は「that」である。 この問題を解決するためにコードを使う人には、英単語が見つかるまで可能性をスキャンし、その単語を保持したまま更新するなど、より多くの選択肢がある。 シンプルだが強力な方法のひとつが、文字の頻度を利用することである。特に、英語の代表的なサンプルを構成するのに十分な長さのメッセージの場合。

チェックインに関する質問

もしよければ、これを解読してみてください。ただし、このモジュールの残りの部分を進める上で必須ではありません。 下の「回答」をクリックしてメッセージを表示してください。

  • これはかなり長くした方がいいと思ったんだ。 そうすれば、人々は解決しやすくなる。 簡単に説明できたと思う。

上記の例では、暗号化された文字から復号化された文字へのマッピングである「キー」が関連付けられている。 この場合、重要なのは

  • A（使わないのでZとする）
  • B->Y
  • C（使わないのでXとする）
  • D->W
  • E->V
  • F->U
  • ...

その他も同様です。 控えめに言っても、これは良いキーではない。 暗号化された文字と復号化された文字が単純にアルファベットをシフトしたもの（A->B、B->Cのように）である鍵は「シーザー・シフト」暗号と呼ばれる。

これらは短いと非常に難しいことに注意してほしい。 実際、非常に短い場合は不定愁訴となる。 以下について考えてください。

URYYP

さまざまなキーを使って、多くの解読が可能だ：hello、petty、happy、jiggy、stool。 他に思い当たることはありますか？

しかし、このようなメッセージを何通も送れば、いずれ暗号は解読されてしまう。 だから、同じ「キー」を頻繁に使うべきではない。 実際、ある代替案を一度だけ使うのがベストだ。 たった1つのメッセージではなく、 たった1つのキャラクターに対してだ！ これは、メッセージで使用される各文字の暗号化スキームやキーを順番に用意することを意味する。 このメッセージを使って友人にメッセージを送りたい場合、あなたと友人は、この刻々と変化するキーが書かれたパッド（昔でいう紙）が必要になる。 これは一度しか使わない。 これは「ワンタイムパッド」と呼ばれる。

ワンタイムパッド

これがどのように機能するか、例で見てみよう。 これをすべて文字で行うこともできるが、文字から数字に変換するのが一般的で、例えば、 A=0、 B=1、 C=2…。 私たちが秘密活動をしている友人で、パッドを共有していたとする。 理想を言えば、多くのパッドを共有することだが、今日はそれだ：

edgrpojncuwqzvmk..

あるいは、アルファベット順の数字に変換する：

4,3,6,17,15, 14, 9, 13, 2, 20, 22, 16, 25, 21, 12, 10..

仮定の話だが、私はこのメッセージを共有したい：

"量子大好き！"

または、次の指定でも等価

8, 11, 14, 21, 4, 16, 20, 0, 13, 19, 20, 12

これは単純な置換であり、まったく安全ではない。 これを何らかの方法でキーと組み合わせたい。 一般的な方法は加算モジュロ26である。 メッセージの末尾に達するまで、メッセージの値をキーの値に加算していく。 というわけで、私たちは

8+4 (mod 26) = 12, 11+3 (mod 26) = 14, 14+6 (mod 26) = 20, 21+17 (mod 26) = 12...

= 12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

もし誰かがこの暗号を傍受し、鍵を持っていない場合、解読は完全に絶望的である！ quantum "の2つの "u "が同じ数字でエンコードされているわけでもない！ 1つ目は3で、2つ目は16...同じ単語だ！

だから、これをあなたに送ります。あなたも私と同じ鍵を持っているはずです。 私が行ったと知っている26モジュロの足し算を元に戻すのだ：

12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

=( 4+x1 ) (mod 26), ( 3+x2 ) (mod 26), ( 6+x3 ) (mod 26), ( 17+x4 ) (mod 26),..

メッセージ x1, x2, x3, x4… は、以下のようでなければならない

8, 11, 14, 21..

最後に、これをテキストに変換すると次のようになる

「量子を愛している」。

これは1回限りのパッドだ。

キーがメッセージより短い場合は、エンコードを繰り返すことになる。 それでも解読は難しいが、何度も繰り返せば不可能ではない。 だから、長いキー（または "パッド"）が必要なのだ。

Note

多くの文脈では、生徒はすでにこの暗号化に慣れているので、この活動は省略できる。 しかし、比較的短時間で簡単にリフレッシュできる。

ステップ1：パートナーを見つけ、キーとなる4文字の並びを共有する。 クラスにふさわしい4文字の並びであれば何でもよい。 \ ステップ2: パートナーに送りたい4文字の秘密の単語を選ぶ(両方のパートナーがこれを行うので、お互いに異なる秘密の単語を送ることになる) \ ステップ3: 4文字のキー/パッドと4文字の秘密の単語を、A = 1、B = 2というように数字に変換する。 \ ステップ4：モジュロ26の加算を使って、4文字の単語とワンタイムパッドを組み合わせる。 \ ステップ5: あなたの秘密の言葉を暗号化した数列をパートナーに手渡し、パートナーもあなたの秘密の言葉を暗号化した数列を手渡す。 \ ステップ6：モジュロ26の引き算を使って、お互いの言葉を解読する。 \ ステップ7：検証 うまくいったのか？

ファローアップ

暗号化された単語を、ワンタイムパッドにアクセスできない別のグループと交換する。 解読できるか？ その理由を説明してほしい

上記の活動で、ワンタイムパッドが解読不可能な暗号化であることが明らかになっただろう：

  • キーは送信されるメッセージと同じ長さか、それ以上である
  • 鍵は本当にランダム
  • キーは一度だけ使用され、その後破棄される

だからこれは素晴らしいことだ。 私たちは解読不可能な暗号を持っている... 誰かが私たちの鍵を盗まない限り。 もし誰かが私たちの鍵を手に入れたら、すべてが解読されてしまう。 解読不可能な暗号化と、すべての秘密が暴露されることのこの違いが、安全な鍵の共有を極めて重要なものにしている。 量子鍵配布の目的は、自然が量子情報に課した制約を利用して、共有鍵／ワンタイムパッドを安全にすることである。

量子状態を鍵として利用する

量子ビットを扱っていると仮定しよう（量子ビットには2つの固有状態があることを強調しておく）。 より多くの量子状態を持つ量子システムを使うこともできるが、 IBM® にある最先端の量子コンピューターは量子ビットを使っている。 A、B、Cを 0’s と 1’s のシーケンスにエンコードするのは問題ない。 従って、 0’s と 1’s の鍵を共有し、文字を格納する各ビットに対して2のモジュロ加算を行えば十分である。

理解度チェック

本当に英字だけにこだわるなら、何ビット必要なのか？

  • 24=1625=32→5 bits2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}

私たちの友人であるアリスとボブは、他の誰にも傍受されないように（少なくとも彼らが知らないうちに）量子鍵を共有したいと考えています。 互いに量子状態を送り合う方法が必要なのだ。 これを忠実に、ノイズやエラーなく行うことは、決して簡単なことではない。 しかし、現時点では2つのアプローチがある：

  1. 光ファイバーケーブルは光を送ることができる...これは非常に量子力学的なものだ。 単一光子は、何キロメートルもの光ファイバーケーブルで忠実に検出することができる。 これは完璧でエラーのない量子チャンネルではないが、非常に優れたものである可能性はある。
  2. 前のモジュールで説明したように、量子テレポーテーションを使うこともできる。 つまり、アリスとボブはもつれた量子ビットを共有し、テレポーテーション・プロトコルを使ってアリスからボブに状態を送ることができる。

このモジュールでは、光子を共有するための忠実度の高い光学系のセットアップを要求したくないので、量子状態を共有するための2番目の方法を使う。 しかし、これは量子鍵の長距離共有が最も現実的であるということではない。

ここでは、 1984年にチャールズ・ベネットとジル・ブラッサールによって初めて考案された、アリスからボブへ異なるベースで測定された状態を共有するためのプロトコルを探求する。 巧妙な測定法を用いて、後の暗号化で使用するキーを構築する。 言い換えれば、私たちは通信を望む2つの当事者間で量子鍵を配布しているのであり、それゆえ「量子鍵配布」（QKD）なのである。

QKDステップ1：アリスによるランダムビットとランダムベース

アリスはまず0と1のランダムなシーケンスを生成する。 そして彼女は、各ランダムビットに基づき、量子状態を準備するための基底を、以下の表（ボブも持っている表）を使ってランダムに選択する：

ベース
ビット = 0
ビット = 1
Z∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle
X∣+⟩\vert +\rangle∣−⟩\vert -\rangle

例えば、アリスがランダムに0を生成し、ランダムにXの基底を選択したとしよう。 そして、量子状態 ∣ψ⟩=∣+⟩x=12(∣0⟩+∣1⟩)|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)。量子のランダム性を利用して、0と1のランダムなセットと、ランダムな基底選択を生成することができるのは確かだ。 とりあえず、以下のようにランダムなセットが生成されたと仮定しよう：

アリスのビット
0
1
0
0
1
1
0
1
0
...
アリスのベースXXZZZXZZX...
アリスの州∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...

このランダムなビット、ベース、そしてその結果の状態のセットは、十分な長さのキーを与えるために、長いシーケンスで続くだろう。

QKDステップ2：ボブのランダムベース

ボブもランダムにベースを選ぶ。 しかし、アリスが自分の状態を準備するために基底の選択を使っていたのに対し、ボブはこれらの基底で実際に測定を行う。 もしボブが、アリスが状態を準備したのと同じ基準で測定をすれば、ボブの測定結果を予測することができる。 アリスが準備に使った基底と違う基底をボブが選んだ場合、ボブの測定結果を知ることはできない。

アリスのビット
0
1
0
0
1
1
0
1
0
...
アリスのベースXXZZZXZZX...
アリスの州∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...
ボブのベースXZXZXXZXX...
ボブの状態（アプリオリ）∣+⟩\vert +\rangle??∣0⟩\vert 0\rangle?∣−⟩\vert -\rangle∣0⟩\vert 0\rangle?∣+⟩\vert +\rangle...
ボブの状態（測定値）∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...

下の表で、最初の列を考えてみよう。 アリスはXの固有状態である状態 ∣+⟩,\vert +\rangle,。ボブもX基底で測定することをランダムに選んだので、ボブの測定状態には1つの結果しかありえない： ∣+⟩.\vert +\rangle. しかし2番目の列では、2人は異なる基底を選んでいる。 アリスが送った状態は、 ∣−⟩=12(∣0⟩−∣1⟩).\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle). これは、ボブが ∣0⟩\vert 0\rangle の状態で測定する確率は50％で、 ∣1⟩.\vert 1\rangle. の状態で測定する確率は50％である。したがって、ボブの測定について先験的にわかっていることを示す行は、列2については埋めることができない。 しかし、ボブは測定を行い、（その列の）Zの固有状態を得る。 下段には、これらの測定で得られた結果を記入した。

QKDステップ3：基盤に関する公開討論

アリスとボブは今、それぞれのケースでどのような根拠を選んだかを互いに共有することができる。 偶然に同じ根拠を選択したすべての列について、彼らはそれぞれ相手がどのような状態であったかを確実に知っている。 ボブは、両者が共有する慣習に従って、状態と基底を0か1に変換することができる。 上の表は、アリスとボブのベースが一致した例だけを示すように書き直すことができる：

アリスのビット
0
0
1
0
0
...
アリスのベースXZXZX...
アリスの州∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
ボブのベースXZXZXX...
ボブの状態（アプリオリ）∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
ボブの状態（測定値）∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
ボブのビット00100...

アリスはビット列00100の送信に成功した。 ボブへ もし友人たちが前もって、ワンタイムパッドの数字として5ビットの文字列を使うことに合意していたとしたら、最初の5ビットが数字になる。 4=0×24+0×23+1×22+0×21+0×20.4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.

QKDステップ4：秘密鍵の確認と送信

アリスとボブは先に進む前に、古典的なビットのサブセットを選んで比較する。 同じ基準で準備され測定された量子ビットの測定値しか保持していないので、すべての測定値は一致するはずである。 一致しない割合が非常に少なかった場合、これは量子ノイズやエラーに起因する可能性がある。 しかし、多くの人が同意しないのであれば、何かが間違っている！

ここでは、鍵の何分の1を検証に使うかについては触れない。 今のところ、このチェックがうまくいったと仮定する。この点については、後述の盗聴のセクションで再確認する。

その後、友人たちは古典的なチャンネルを使って暗号化されたメッセージを送り合う。 そして、ワンタイムパッドの数字を使って秘密のメッセージを暗号化／復号化する。 盗聴に関する次のセクションでは、暗号化された秘密が古典的なチャネルを通じて暴露される前に、このような鍵の共有がすべて行われることに留意してほしい。

アリスとボブは古典的なチャンネルを使って選択の根拠を伝えた そのとおりです! しかし、彼らがどのような基準で計測したかを知るだけでは、彼らがどのようなビットを送ったのか、あるいは入手したのかはわからない。 それが可能なのは、アリスのスタートビットを知っている場合だけだ。 しかし、その場合、あなたは秘密が保存されているアリスのコンピュータの中にいることになり、秘密の通信は無意味になる。 そのため、古典的な通信を傍受しても、暗号が破られることはない。 しかし、量子チャンネルで情報を傍受するのはどうだろう？

量子鍵配送（QKD）の盗聴に対する耐性

アリスとボブには盗聴で有名な友人イブがいる。 EveはAliceとBobの量子鍵を傍受し、2人の間で送信されるメッセージの解読に使いたい。 アリスが状態を準備してからボブが状態を測定するまでの間に、測定が量子状態を崩壊させるので、これは必然的に起こる。 特に、盗聴は基地の共有や比較が行われる前に行われなければならないということだ。

イヴは、各ビットのエンコードにどのベースが使われたかを推測しなければならない。 繰り返すが、もし彼女がアリスのコンピューターにアクセスできなければ、この推測の根拠となるものは何もない。 アリスのスタートが以前と同じであると仮定し、さらにボブの測定基準のランダムな選択が以前と同じであると仮定しよう。 イヴが量子チャンネルを測定した場合、何が得られるかを埋めてみよう。 先ほどと同じように、イヴがたまたまアリスと同じベースを選択した場合、彼女が何を得るかはわかっている。 そうでない場合、彼女は2つの結果のどちらかを得る可能性があり、それぞれの確率は50％である。

アリスのビット
0
1
0
0
1
1
0
1
0
...
アリスのベースXXZZZXZZX...
アリスの州∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...
イヴの推測ベースZXXZXZZXX...
イブの状態（アプリオリ）?∣−⟩\vert -\rangle?∣0⟩\vert 0\rangle??∣0⟩\vert 0\rangle?∣+⟩\vert +\rangle...
イブの状態（測定値）∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
ボブのベースXZXZXXZXX...

今、イブはアリスの基礎と一致したかどうかを知らないので、アリスの元の状態と一致させるためにボブに何を送信すればいいのかわからない。 例えば、イヴが ∣0⟩,|0\rangle,、彼女が確実に知っているのは、 アリスがその量子ビットの状態 ∣1⟩|1\rangle。 しかし、アリスは ∣0⟩,|0\rangle, ∣+⟩,|+\rangle,、または ∣−⟩.|-\rangle. すべてがイヴの測定と一致する可能性がある。 だから、イブは選択しなければならない。 彼女は自分が測定した状態を正確に送るかもしれないし、自分の測定がアリスから送られた固有状態でない例を推測しようとするかもしれない。 私たちのテーブルにはミックスを入れる：

アリスのビット
0
1
0
0
1
1
0
1
0
...
アリスのベースXXZZZXZZX...
アリスの州∣+⟩\vert +\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣+⟩\vert +\rangle...
イヴの推測ベースZXXZXZZXX...
イブの状態（アプリオリ）?∣−⟩\vert -\rangle?∣0⟩\vert 0\rangle??∣0⟩\vert 0\rangle?∣+⟩\vert +\rangle...
イブの状態（測定値）∣1⟩\vert 1\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
イブの状態（送信済み）∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle...
ボブのベースXZXZXXZXX...
ボブの状態（アプリオリ）?∣0⟩\vert 0\rangle?∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
ボブの状態（測定値）∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣+⟩\vert +\rangle...
ボブのビット100010010...

この時点で、"なぜイヴはアリスの量子状態のコピーを作り、一方を測定用に保存しておき、もう一方をボブに送信しないのか？"と問うのが妥当だろう 答えは 「ノー・クローン」の定理である。 非公式に言えば、任意の量子状態の2つ目のコピーを、1つ目のコピーを保持したまま作ることのできるユニタリー（量子力学的）操作は存在しない、ということである。 証明は比較的簡単なので、ガイド付きの練習問題として残しておく。 しかし今は、イヴが量子状態のコピーを作ることは自然界の基本法則によって禁じられており、これがQKDの原則的な強みであることを理解してほしい。

以前と同じように、アリスとボブはお互いに電話をかけ、ベースを比較する。 この表を、2人の友人が同じベースを選択したケースに縮小する：

アリスのビット
0
0
1
0
0
...
アリスのベースXZXZX...
アリスの州∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
イヴの推測ベースZZZZX...
イブの状態（アプリオリ）?∣0⟩\vert 0\rangle?∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
イブの状態（測定値）∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
イブの状態（送信済み）∣1⟩\vert 1\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣0⟩\vert 0\rangle...
ボブのベースXZXZX...
ボブの状態（アプリオリ）?∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
ボブの状態（測定値）∣−⟩\vert -\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle∣0⟩\vert 0\rangle∣+⟩\vert +\rangle...
ボブのビット10000...

アリスとボブは再びビット列を通信した。 しかし、文字列は一致しない。 左端と中央のビットが反転している。 先ほどの表を見ると、このミスマッチはイブからの妨害に起因していることがわかる。 重要なのは、暗号化された秘密を共有するずっと前に、鍵をセットアップしている間に、ビット列のマッチングを統計することができるということだ。 アリスとボブは、自分たちのチャネルの安全性を確認するために、ワンタイムパッドのビットを好きなだけ自由に使うことができる。 1ビット、あるいはごく一部のビットが一致しなかった場合、これはノイズやエラーに起因する可能性がある。 しかし、ミスマッチのかなりの部分が盗聴であることを示している。 ここでの "実質的 "の意味は、使用されるセットアップのノイズに少し依存する。 IBM® 量子コンピュータが何を意味するかは、このプロトコルを実装する際に後述する。 過剰なエラーが検出された場合、アリスとボブは秘密を共有せず、盗聴者を探し始めることができる。

警告

安全性を証明するのは非常に難しい。 実際、ここで大まかに説明したプロトコルは1984年に提案されたもので、安全性が証明されたのはそれから16年後のことである。 この紹介の範囲を超えている微妙な点がたくさんある。 しかし、このトピックがここで説明されている以上に複雑であることを示すために、いくつか簡単に挙げておこう。

  • 安全なチャンネルアリスが量子セットアップ（チャネル）を通して量子ビットを送信し、特に誰かから古典的な応答を聞くとき、我々はその誰かが実際にボブであると仮定した。 もしイヴがこのセットアップに潜入し、アリスの通信がすべてイヴとの間で実際に行われ、ボブの通信がすべてイヴとの間で実際に行われたとしたら、イヴは事実上鍵を手に入れたことになり、秘密を知ることができる。 まず「安全なチャンネル」を確保しなければならないが、このプロセスには別のプロトコルが必要であり、ここでは扱わない。
  • イヴについての仮定： イブは常に我々の予想を裏切る可能性がある。 ここでは具体的な例を挙げると、私たちは仮定を立てている。 例えば、イヴがボブに送信する状態は、常にイヴが測定時に得た状態そのものであると仮定することができる。 あるいは、彼女が実験的に自分の測定と一致する状態をランダムに選ぶと仮定するかもしれない。 より基本的なことを言えば、ここではイヴが、別の量子系に状態を保存してボブにランダムな量子ビットを送るのとは対照的に、実際に測定を行うことを前提としている。 これらの仮定はプロトコルを理解する上では問題ないが、完全な一般性を証明するものではないことを意味する。
  • プライバシーの増幅： アリスとボブは送信された量子鍵を正確に使う必要はない。 例えば、共有鍵にハッシュ関数を適用することができる。 これは、盗聴者が鍵について不完全な知識を持っていることを利用し、より短いが安全な共有鍵を生成するものである。

実験1：盗聴者なしの量子鍵配送（QKD）

盗聴者がいない場合の上記のプロトコルを実装してみよう。 まずはシミュレーターを使って、単純にワークフローを理解する。

まず、量子シミュレーターについて：30量子ビットを超える量子問題は、ほとんどのコンピュータではシミュレートできません。 古典的なコンピュータ、スーパーコンピュータ、GPUでは、127量子ビットの量子コンピュータのすべての動作をシミュレートすることはできない。 通常、本物の量子コンピュータを使う動機は、多数のもつれた量子ビットをシミュレートできないからである。 この場合、テレポーテーション方式で情報を移動させない限り、量子ビットのもつれは生じない。 この場合、本物の量子コンピューターを使う動機は異なる。 量子ビットをシミュレートした古典的なコンピューターは、量子状態に関する情報をアリスからボブに送ることができるが、この古典的な情報が傍受された場合、簡単に複製することができ、イブは完全なコピーを保持しながら、別の情報をボブに送ることができる。 これは現実の量子状態では不可能だ。

IBM Quantumは、我々が「Qiskitパターン」と呼ぶフレームワークを使って量子コンピューティングの問題に取り組むことを推奨している。 以下のステップで構成される。

  • ステップ1：問題を量子回路にマップする
  • ステップ2：実際の量子ハードウェア上で動作するように回路を最適化する
  • ステップ 3: ランタイム・プリミティブを使って、 IBM 量子コンピュータ上でジョブを実行する
  • ステップ4：結果の後処理

Qiskitパターン ステップ1: 問題を量子回路にマッピングする

この場合、我々の問題を量子回路にマッピングすることは、単にアリスの状態を準備し、次にボブの測定値を含めることになる。 まず、ランダムビットとランダム基底の選択から始める。

# Qiskit patterns step 1: Map your problem to quantum circuit
# Import some generic packages

import numpy as np
from qiskit import QuantumCircuit

# Set up a random number generator and a quantum circuit. We choose to start with 20 bits, though
# any number <30 should be fine.

rng = np.random.default_rng()
bit_num = 20
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Random bits and bases for Alice
# generate Alice's random bits

abits = np.round(rng.random(bit_num))

# generate Alice's random measurement bases. Here we will associate a "0" with the Z basis, and a
# "1" with the X basis.

abase = np.round(rng.random(bit_num))

# Alice's state preparation. Check that this creates states according to table 1

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob
# generate Bob's random measurement bases.

bbase = np.round(rng.random(bit_num))

# Note that if Bob measures in Z no gates are necessary, since IBM Quantum computers
# measure in Z by default.
# If Bob measures in the X basis, we implement a hadamard gate qc.h to facilitate the measurement.

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

ビット、ベース、回路を視覚化してみよう。 ベースが一致することもあれば、一致しないこともある。

print("Alice's bits are ", abits)
print("Alice's bases are ", abase)
print("Bob's bases are ", bbase)
qc.draw("mpl")

Output:

Alice's bits are  [1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0.]
Alice's bases are  [0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0.]
Bob's bases are  [0. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0.]
Output of the previous code cell

Qiskitパターンステップ2：量子実行のための問題最適化

このステップでは、私たちが実行したいオペレーションを、特定の量子コンピュータの機能の観点から表現する。 また、我々の問題を量子コンピューターのレイアウトにマッピングすることもできる。

まず、 IBM 量子コンピューターと通信するために必要なパッケージをいくつかロードする。 また、実行するバックエンドも選択しなければならない。 最も忙しくないバックエンドを選ぶか、プロパティがわかっている特定のバックエンドを選ぶことができる。 一時的にシミュレータを使用しますが、シミュレーションでは合理的なノイズモデルを使用することが重要であり、後に実際の量子コンピュータで使用するワークフローにできるだけ近づけることが望ましいです。

初回使用時に認証情報を保存するためのコードが以下にあります。 ノートブックを自分の環境に保存した後、必ずこの情報をノートブックから削除してください。そうすれば、ノートブックを共有するときにあなたの認証情報が誤って共有されることはありません。 詳しいガイダンスについては、 IBM Cloud アカウントの設定および信頼できない環境でのサービスの初期化を参照してください。

# Load IBM Quantum Compute Service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load IBM Quantum Compute Service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',
# instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()


# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
# backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)
backend = service.backend("ibm_brisbane")
print(backend.name)

Output:

ibm_brisbane

以下では、シミュレーターとノイズモデルを選択する。

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

# Load the qiskit runtime sampler
from qiskit_ibm_runtime import SamplerV2 as Sampler


noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)
# Qiskit patterns step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

Qiskit パターン ステップ 3: 実行

サンプラーを使用して、回路を引数としてジョブを実行する。

# This required 5 s to run on a Heron r2 processor on 10-28-24
sampler = Sampler(mode=backend)
job = sampler.run([qc_isa], shots=1)
# job = sampler_sim.run([qc], shots = 1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Qiskitパターン ステップ4: 後処理

ここでは結果を解釈し、有益な情報を抽出する。 サンプラーの出力を視覚化してみるのもいいかもしれないが、私たちはサンプラーを型破りな方法で使っている。 私たちの回路を何度も測定し、その状態を統計するのではなく、たった1回（ボブの）測定しただけです。 同じ基準で準備され測定された状態を持つどの量子ビットも、決定論的な結果を持つはずであり、そのような場合、必要な測定は1回だけである。 異なるベースで準備され測定された状態の量子ビット（これは確率的な結果を持ち、解釈するために多くの測定を必要とする）は、ワンタイムパッド／キーの構築に使われることはない。

このビット列から測定結果のリストを取り出してみよう。 回路の生成に使ったアリスのビット配列と比較する場合は、順序を逆にするように注意すること。

# Get an array of bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))

# Reverse the order to match our input. See "little endian" notation.

bbits = bmeas_ints[::-1]

print(bbits)

Output:

[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0]

アリスとボブがランダムに選んだ測定ベースを比較してみよう。 これが私たちのQKDプロトコルのステップ3（ベースの公開ディスカッション）だった。 量子ビットに同じ基底を選んだ場合はいつでも、その量子ビットに関連するビットを、ワンタイムパッドの数字を生成するためのビットリストに追加する。 ベースが一致しない場合、結果は破棄される。 また、2つのビットのリストが一致しているか、ノイズやその他の要因によるロスがなかったかも確認しよう。

# QKD step 3: Public discussion of bases

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    # Check whether bases matched.
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        # If bits match when bases matched, increase count of matching bits
        if int(abits[n]) == bbits[n]:
            match_count += 1

print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 0, 1, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 1, 0]
fidelity =  1.0
loss =  0.0

アリスとボブはそれぞれビットのリストを持っており、100％の忠実度で一致する。 これらを使ってワンタイムパッドの数字を生成することができる。 そして、QKDのステップ4である秘密の送信と復号に使うことができる。 現在のビット配列は、解読するには短すぎる。 これについては、盗聴を含めてからまた触れたい。

理解度チェック

英語アルファベットの文字をアルファベット全長分、あるいはそれ以上ずらすのに十分な大きさの数字が必要だと仮定する。 (a) 上記の鍵のビットを使って解読できるメッセージの長さは何文字か？ (b) あなたの答えはクラスメートの答えと一致しなければなりませんか？ その理由は何か?

  • (a) その答えは、アリスとボブの間で、ランダムに選ばれた塩基のうちいくつが一致したかによって決まる。 どの量子ビットについても、ベースが一致する確率はおよそ50％であるため、10ビット近くが有用であると予想されます。 9や11はごく一般的になるでしょう。 4や15でさえ、あり得ないことではない。 英字アルファベットの文字数以上の桁数だけシフトするには5ビットが必要です。つまり、5ビットごとに1文字のシフト処理を行うことができます。 アリスとボブが共有するビットが5ビット以上あれば、1文字を符号化することができます。 10以上あれば2文字を符号化でき、以下同様です。

    (b) (a)で述べた理由により、一致する必要はない。

実験2：盗聴者を伴う量子鍵配送（QKD）

以前とまったく同じプロトコルを実装する。 今度は、アリスとボブの間に、イヴによる別の測定セットを挿入する。

from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Qiskit patterns step 1: Mapping your problem to a quantum circuit
# QKD step 1: Random bits and bases for Alice

bit_num = 20
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Alice's random bits and bases, as before

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation, as before

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])
# Qiskit patterns step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
# Qiskit patterns step 3: Execute
job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

この場合、Qiskitパターンのステップ4（後処理）は簡単です。 測定は1回だけなので、測定値の分布を可視化する必要はない。 イブには以下のビットがある：

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

print(ebits)

Output:

[0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]

さて、イヴはボブに送る状態を再構築しなければならない。 冒頭で述べたように、彼女はエンコーディングのベースを正しく推測したかどうかを知る術がないので、送信されたものとまったく同じ状態を準備することはできない。 彼女はすべての基底の選択が正しいと仮定し、測定したものを正確に符号化することもできるし、基底の選択が間違っていたと仮定し、反対の基底の固有状態のいずれかを選択することもできる。 ここでは簡単のため、前者を仮定する。 私たちは、以前と同じようにQiskitパターンのステップを繰り返しながら、まったく新しい量子回路を構築することでこれを達成する。

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit patterns step 1: Mapping your problem onto a quantum circuit
# QKD step 1: Eve uses her measurements to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)


# Qiskit patterns step 3: Execute

job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

print(bbits)

Output:

[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]

ここでアリスとボブのビットを比較してみよう：

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1
print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 1]
fidelity =  0.8571428571428571
loss =  0.1428571428571429

以前は、アリスとボブの鍵のビットは完全に一致していた。 さて、イヴの妨害から、アリスとボブが同じベースを選択したために、一致するはずの14%のケースで、アリスとボブのビットが異なっていることがわかる。 これはアリスとボブにとって簡単に発見できるはずだ。 しかし、このような誤差の割合に頼るということは、量子チャンネルで許容できるノイズの量に限界があることを意味する。

実験3：実際の量子コンピュータにおける盗聴の有無によるQKDの比較

これを実際の量子コンピューターで動かしてみよう。 そうすれば、ノー・クローンの定理を活用できる。 同時に、実際の量子コンピューターにはノイズがあり、古典的なコンピューターよりもエラー率が高い。 そこで、盗聴の有無による鍵ビットの忠実度の損失を比較し、実際の量子コンピュータを使用した場合にその違いが検出可能かどうかを確認してみよう。 盗聴のないところから始めよう：

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 3 sec to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)


# Qiskit patterns step 2: Transpilation

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Load the Runtime primitive and session
sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's measurement bases and collect usable bits

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
Bob's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
fidelity =  0.9682539682539683
loss =  0.031746031746031744

盗聴されることなく、この127の試行ビットセットに対して100％の忠実度が得られ、55の一致したベースと使用可能なキービットが得られた。 では、この実験をイヴに聴かせて繰り返してみよう：

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 2 s to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)


# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Eve's bits

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

# print(ebits)

# Restart process
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

# QKD step 1: Eve uses her measurements above to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)


# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit Patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's bases, when they are the same, keep the bits.

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1]
Bob's bits =  [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
fidelity =  0.7619047619047619
loss =  0.23809523809523814

ここでは、盗聴による共有ビットの忠実度の損失がほぼ23％であることがわかった！ これは非常にわかりやすい！ 量子情報を長距離伝送する場合、さらなるノイズやエラーが発生する可能性がある。 ノイズがあっても、イヴがあらゆるトリックを駆使しても、盗聴が検知されることを保証することは、この紹介の域を出ない複雑な分野である。

質問

指導者は、このノートがどのように使用されているかについての簡単なアンケートに答えることで、解答と一般的なカリキュラムにおける配置についてのガイダンスが付いたバージョンのノートを要求することができる。

重要な概念

  • 量子情報はコピーも「クローン」もできない。
  • 同じ準備プロセスを繰り返すことで、すべて同じ、あるいはほぼ同じ量子状態のアンサンブルを作ることができる。
  • 暗号化／復号化キー（ワンタイムパッド）は、量子状態を用いて2人の友人間で共有することができる。
  • 2人の友人がランダムに測定基準を選ぶということは、半分の時間は異なる選択をし、それらの量子ビットの情報を捨てなければならないことを意味する。
  • 測定基準をランダムに選択することで、盗聴者は準備された初期状態を知ることができず、したがって送信された状態を再現できないことも保証される。 これにより、盗聴は確実に検知される。

正誤問題

  1. T/F 量子鍵配布では、通信を行う2人のパートナーは、それぞれの量子ビットを同じ基底で測定する。
  2. T/F QKDで量子情報を傍受する盗聴者は、自然の法則によって、傍受した量子状態をコピーすることができない。
  3. T/F ワンタイムパッドとは、安全なメッセージを暗号化／復号化するための鍵で、特定の符号化方式が1つの情報（アルファベットの1文字など）に対して1度だけ使われる。

MCの質問

  1. 最も適切な選択肢を選んでください。 このモジュールで説明するように、ワンタイムパッドとは、暗号化／復号化キーのセットである。
  • a. 一文字のような単一の情報に対して一度だけ。
  • b. 一つのメッセージに対して一度だけ。
  • c. 1日など決まった期間に1回だけ。
  • d. 盗聴の証拠が出るまでは。
  1. アリスとボブが測定ベースをランダムに選ぶと仮定する。 彼らは測定する。 そして、測定ベースを共有し、同じベースを使用したケースの情報の断片だけを保管する。 あるランダムな揺らぎがあるとして、その量子ビットのおよそ何パーセントが使用可能な情報ビットになるのだろうか？
  • a. 100％
  • b. 50％
  • c. 25％
  • d. 12.5%
  • e. 0％
  1. アリスとボブが同じ測定ベースを使用したケースを選択した後、量子ノイズと誤差が無視できるものであれば、それらの情報の何パーセントが一致するはずだろうか？
  • a. 100％
  • b. 50％
  • c. 25％
  • d. 12.5%
  • e. 0％
  1. アリスが測定ベースをランダムに選んだと仮定する。 イヴもランダムにベースを選び、（小節を）聞き込む。 彼女は自分の測定値と一致する状態をボブに送る。 アリスとボブは基底の選択を比較し、同じ基底で測定/準備された量子ビットだけを保持する。 アリスとボブによれば、あるランダムな揺らぎまでは、これらの保持された量子ビットの測定値のうち、およそ何パーセントが一致するのだろうか？
  • a. 100％
  • b. 75％
  • c. 50％
  • d. 25％
  • e. 12.5%
  • f. 0％

議論における疑問点:

  1. すべての参加者（アリス、ボブ、イヴ）にとって、すべての基礎選択はランダムであると仮定する。 イヴが盗聴した後、自分が測定したのと同じベースで準備され、その測定と一致する状態をボブに送ると仮定する。 アリスによって初期化された全ての量子ビットのうち、 12.5 %がアリスとボブの間で測定の不一致を引き起こし、盗聴を示すことをパートナーに納得させる(量子エラーやノイズは無視する)。 ヒント1：優先順位がないので、アリスの最初の選択肢を1つだけ考えれば、その1つの選択肢の比率は、すべての選択肢の合計の比率と同じになるはずである。 ヒント2：何かが起こる可能性の数を数えるだけでは十分ではないかもしれない。

  2. アリス、ボブ、イヴのすべての参加者について、すべての基礎の選択がランダムであると再び仮定する。 しかし今、イブは測定後に好きな状態を自由に送ることができると考えてみよう。 彼女自身の測定値と矛盾する状態を送ってみることだってできる。 アリスとボブが盗聴していることを示す量子ビットの平均的なパーセンテージを下げるような基底の選択があると思うかどうか、パートナーや隣人と議論しなさい。

このページは役に立ちましたか？
バグや誤字の報告、またはコンテンツの要求はGitHubで行ってください。