カットベルペアを用いた動的回路のベンチマーク
使用時間推定値: Heron r2 プロセッサ上で22秒（注: これはあくまで推定値です） 実行時間は異なる場合があります。
学習成果
このチュートリアルを終えた後、ユーザーは以下の点を理解できるようになります：
- 回路の途中での測定と古典的なフィードフォワードを用いて動的な回路を構築し、離れた量子ビット間のエンタングルメントをテレポーテーションする方法；
- デバイス全体におけるベル対の忠実度を定量化するための誤差指標の算出方法と解釈；
- ベンチマーク結果を用いて、LOCCベースの演算に最適な量子ビットペアを特定する方法。
前提条件
このチュートリアルを進める前に、以下の内容についてあらかじめ理解しておいていただくことをお勧めします：
- ベル状態、量子もつれ、量子ゲートなど、 量子コンピューティングの基礎概念；
- 動的回路に関する知識（ 回路の途中での測定および古典的なフィードフォワード）；
- Qiskit SDK および IBM Quantum® Compute Service に関する基礎知識、ならびに IBM Quantum アカウントへのアクセス権。
背景
量子ハードウェアは通常、局所的な相互作用に限定されるが、多くのアルゴリズムでは遠隔の量子ビット、あるいは別々のプロセッサ上の量子ビットを絡み合わせる必要がある。 動的回路——すなわち、回路途中での測定とフィードフォワードを備えた回路——は、リアルタイムの古典的通信を用いて非局所的な量子操作を効果的に実現することで、これらの制限を克服する方法を提供する。 この手法では、回路の一部（または1つのQPU）における測定結果が、条件付きで別の部分のゲートをトリガーすることができ、これにより長距離にわたってエンタングルメントをテレポーテーションすることが可能となる。 これは、 局所操作と古典通信（LOCC） スキームの基盤を成す。このスキームでは、絡み合った資源状態（ベル対）を消費し、測定結果を古典的に通信することで遠隔の量子ビットを連結する。
LOCCの有望な応用例の一つは、 長距離エンタングルメントチュートリアルで示されているように、テレポーテーションによる仮想的な長距離CNOTゲートの実現である。 直接的な長距離CNOT（ハードウェアの接続性が許さない可能性がある）の代わりに、ベル対を作成し、テレポーテーションに基づくゲート実装を行う。 ただし、このような操作の忠実度はハードウェアの特性に依存する。 必要な遅延時間（測定結果待ちの間）における量子ビットのデコヒーレンスと古典通信の遅延は、もつれた状態を劣化させる可能性がある。 また、中間回路測定の誤差は、条件付きゲートを通じて回路全体に伝播するため、最終測定の誤差よりも修正が困難である。
参照実験において、著者らは、デバイスのどの部分がLOCCベースのエンタングルメントに最も適しているかを特定するため、ベル対のフィデリティに関するベンチマークを導入している。 その考え方は、プロセッサ内の4つの量子ビットが接続された各グループに対して、小さな動的回路を実行するというものです。 この4量子ビット回路は、まず中央の2つの量子ビットでベル対を生成し、それをリソースとして利用して、LOCCを用いて両端の2つの量子ビットをエンタングルメントさせる。 具体的には、量子ビット1と2を、ローカルに生成された未切断のベル対（テレポーテーションを用いず、ハダマール演算とCNOT演算によって直接生成されたベル対）として準備し、その後、テレポーテーション処理によってそのベル対を消費し、量子ビット0と3をエンタングルメントさせる。 回路の実行中に量子ビット1と2の測定が行われ、その結果に基づいて、パウリ補正（量子ビット3にX、量子ビット0にZ）が適用される。 こうして、回路の終了時点で量子ビット0と3はベル状態のまま残される。
この最終的なもつれた対の質を定量化するため、その安定化子（具体的には、基底 におけるパリティ（ ）と 基底 におけるパリティ（ ））を測定する。完全なベル対の場合、これらの期待値はいずれも +1 に等しい。 実際には、ハードウェアノイズによりこれらの値は低下します。 したがって、各量子ビットペアに対して回路を2回繰り返す：1つの回路は量子ビット0と3を 基底で測定し、別の回路は基底 で測定する。 結果から、その量子ビットのペアに対する と の推定値が得られる。 これらの安定化器の理想値(1)に対する二乗誤差の平均(MSE)を、エンタングルメント忠実度の単純な指標として用いる。 MSEが低いほど、2つの量子ビットが理想的なベル状態に近づいた（忠実度が高い）ことを意味し、MSEが高いほど誤りが多いことを示す。 この実験をデバイス全体でスキャンすることで、異なる量子ビット群の測定・フィードフォワード能力をベンチマークし、LOCC演算に最適な量子ビットペアを特定できる。
このチュートリアルでは、 IBM Quantum® デバイスを用いた実験を紹介し、動的回路を用いて離れた位置にある量子ビット間のエンタングルメントを生成・評価する方法を解説します。 このデバイス上のすべての4量子ビット線形鎖をマッピングし、それぞれでテレポーテーション回路を実行した後、MSE値の分布を可視化します。 このエンドツーエンドの手順では、 IBM Quantum のCompute Serviceおよび動的回路機能を活用し、モジュール式システムにおいて回路を分割したり、量子アルゴリズムを分散させたりする際に、ハードウェアの特性を考慮した適切な選択を行う方法を示します。
要件
このチュートリアルを始める前に、以下のものがインストールされていることを確認してください：
- Qiskit SDK v2.0 またはそれ以降、 可視化サポート付き
- v0.40Qiskit Runtime またはそれ以降 (
pip install qiskit-ibm-runtime) - Qiskit Aer v0.17 以降 (
pip install qiskit-aer)
セットアップ
from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit.transpiler import generate_preset_pass_manager
import numpy as np
import matplotlib.pyplot as plt
def create_bell_stab(initial_layouts):
"""
Create a circuit for a 1D chain of qubits (number
of qubits must be a multiple of 4), where a middle
Bell pair is consumed to create a Bell at the edge.
Takes as input a list of lists, where each element
of the list is a 1D chain of physical qubits that is
used as the initial_layout for the transpiled circuit.
Returns a list of length-2 tuples, each tuple
contains a circuit to measure the ZZ stabilizer and
a circuit to measure the XX stabilizer of the edge
Bell state.
"""
bell_circuits = []
for (
initial_layout
) in initial_layouts: # Iterate over chains of physical qubits
assert (
len(initial_layout) % 4 == 0
), "The length of the chain must be a multiple of 4, "
f"len(inital_layout)={len(initial_layout)}"
num_pairs = len(initial_layout) // 4
bell_parallel = QuantumCircuit(4 * num_pairs, 4 * num_pairs)
for pair_idx in range(num_pairs):
(q0, q1, q2, q3) = (
pair_idx * 4,
pair_idx * 4 + 1,
pair_idx * 4 + 2,
pair_idx * 4 + 3,
)
(c0, c1) = pair_idx * 4, pair_idx * 4 + 3 # edge qubits
(ca0, ca1) = pair_idx * 4 + 1, pair_idx * 4 + 2 # middle qubits
bell_parallel.h(q0)
bell_parallel.h(q1)
bell_parallel.cx(q1, q2)
bell_parallel.cx(q0, q1)
bell_parallel.cx(q2, q3)
bell_parallel.h(q2)
# add barrier BEFORE measurements and add id in conditional
bell_parallel.barrier()
for pair_idx in range(num_pairs):
(q0, q1, q2, q3) = (
pair_idx * 4,
pair_idx * 4 + 1,
pair_idx * 4 + 2,
pair_idx * 4 + 3,
)
(ca0, ca1) = pair_idx * 4 + 1, pair_idx * 4 + 2 # middle qubits
bell_parallel.measure(q1, ca0)
bell_parallel.measure(q2, ca1)
# bell_parallel.barrier() #remove barrier after measurement
for pair_idx in range(num_pairs):
(q0, q1, q2, q3) = (
pair_idx * 4,
pair_idx * 4 + 1,
pair_idx * 4 + 2,
pair_idx * 4 + 3,
)
(ca0, ca1) = pair_idx * 4 + 1, pair_idx * 4 + 2 # middle qubits
with bell_parallel.if_test((ca0, 1)):
bell_parallel.x(q3)
with bell_parallel.if_test((ca1, 1)):
bell_parallel.z(q0)
bell_parallel.id(q0) # add id here for correct alignment
bell_zz = bell_parallel.copy()
bell_zz.barrier()
bell_xx = bell_parallel.copy()
bell_xx.barrier()
for pair_idx in range(num_pairs):
(q0, q1, q2, q3) = (
pair_idx * 4,
pair_idx * 4 + 1,
pair_idx * 4 + 2,
pair_idx * 4 + 3,
)
bell_xx.h(q0)
bell_xx.h(q3)
bell_xx.barrier()
for pair_idx in range(num_pairs):
(q0, q1, q2, q3) = (
pair_idx * 4,
pair_idx * 4 + 1,
pair_idx * 4 + 2,
pair_idx * 4 + 3,
)
(c0, c1) = pair_idx * 4, pair_idx * 4 + 3 # edge qubits
bell_zz.measure(q0, c0)
bell_zz.measure(q3, c1)
bell_xx.measure(q0, c0)
bell_xx.measure(q3, c1)
bell_circuits.append(bell_zz)
bell_circuits.append(bell_xx)
return bell_circuits
def get_mse(result, initial_layouts):
"""
given a result object and the initial layouts,
returns a dict of layouts and their mse
"""
layout_mse = {}
for layout_idx, initial_layout in enumerate(initial_layouts):
layout_mse[tuple(initial_layout)] = {}
num_pairs = len(initial_layout) // 4
counts_zz = result[2 * layout_idx].data.c.get_counts()
total_shots = sum(counts_zz.values())
# Get ZZ expectation value
exp_zz_list = []
for pair_idx in range(num_pairs):
exp_zz = 0
for bitstr, shots in counts_zz.items():
bitstr = bitstr[::-1] # reverse order to big endian
b1, b0 = (
bitstr[pair_idx * 4],
bitstr[pair_idx * 4 + 3],
) # parse bitstring to get edge measurements for each 4-q chain
z_val0 = 1 if b0 == "0" else -1
z_val1 = 1 if b1 == "0" else -1
exp_zz += z_val0 * z_val1 * shots
exp_zz /= total_shots
exp_zz_list.append(exp_zz)
counts_xx = result[2 * layout_idx + 1].data.c.get_counts()
total_shots = sum(counts_xx.values())
# Get XX expectation value
exp_xx_list = []
for pair_idx in range(num_pairs):
exp_xx = 0
for bitstr, shots in counts_xx.items():
bitstr = bitstr[::-1] # reverse order to big endian
b1, b0 = (
bitstr[pair_idx * 4],
bitstr[pair_idx * 4 + 3],
) # parse bitstring to get edge measurements for each 4-q chain
x_val0 = 1 if b0 == "0" else -1
x_val1 = 1 if b1 == "0" else -1
exp_xx += x_val0 * x_val1 * shots
exp_xx /= total_shots
exp_xx_list.append(exp_xx)
mse_list = [
((exp_zz - 1) ** 2 + (exp_xx - 1) ** 2) / 2
for exp_zz, exp_xx in zip(exp_zz_list, exp_xx_list)
]
print(f"layout {initial_layout}")
for idx in range(num_pairs):
layout_mse[tuple(initial_layout)][
tuple(initial_layout[4 * idx : 4 * idx + 4])
] = mse_list[idx]
print(
f"qubits: {initial_layout[4*idx:4*idx+4]}, mse:, "
f"{round(mse_list[idx],4)}"
)
# print(f'exp_zz: {round(exp_zz_list[idx],4)},
# exp_xx: {round(exp_xx_list[idx],4)}')
print(" ")
return layout_mse
def plot_mse_ecdfs(layouts_mse, combine_layouts=False):
"""
Plot CDF of MSE data for multiple layouts.
Optionally combine all data in a single CDF
"""
if not combine_layouts:
for initial_layout, layouts in layouts_mse.items():
sorted_layouts = dict(
sorted(layouts.items(), key=lambda item: item[1])
) # sort layouts by mse
# get layouts and mses
layout_list = list(sorted_layouts.keys())
mse_list = np.asarray(list(sorted_layouts.values()))
# convert to numpy
x = np.array(mse_list)
y = np.arange(1, len(x) + 1) / len(x)
# Prepend (x[0], 0) to start CDF at zero
x = np.insert(x, 0, x[0])
y = np.insert(y, 0, 0)
# Create the plot
plt.plot(
x,
y,
marker="x",
linestyle="-",
label=f"qubits: {initial_layout}",
)
# add qubits labels for the edge pairs
for xi, yi, q in zip(x[1:], y[1:], layout_list):
plt.annotate(
[q[0], q[3]],
(xi, yi),
textcoords="offset points",
xytext=(5, -10),
ha="left",
fontsize=8,
)
elif combine_layouts:
all_layouts = {}
all_initial_layout = []
for (
initial_layout,
layouts,
) in layouts_mse.items(): # puts together all layout information
all_layouts.update(layouts)
all_initial_layout += initial_layout
sorted_layouts = dict(
sorted(all_layouts.items(), key=lambda item: item[1])
) # sort layouts by mse
# get layouts and mses
layout_list = list(sorted_layouts.keys())
mse_list = np.asarray(list(sorted_layouts.values()))
# convert to numpy
x = np.array(mse_list)
y = np.arange(1, len(x) + 1) / len(x)
# Prepend (x[0], 0) to start CDF at zero
x = np.insert(x, 0, x[0])
y = np.insert(y, 0, 0)
# Create the plot
plt.plot(
x,
y,
marker="x",
linestyle="-",
label=f"qubits: {sorted(list(set(all_initial_layout)))}",
)
# add qubit labels for the edge pairs
for xi, yi, q in zip(x[1:], y[1:], layout_list):
plt.annotate(
[q[0], q[3]],
(xi, yi),
textcoords="offset points",
xytext=(5, -10),
ha="left",
fontsize=8,
)
plt.xscale("log")
plt.xlabel("Mean squared error of ⟨ZZ⟩ and ⟨XX⟩")
plt.ylabel("Cumulative distribution function")
plt.title("CDF for different initial layouts")
plt.grid(alpha=0.3)
plt.show()小規模シミュレータの例
実際のQPU上で実行する前に、4量子ビットのチェーンを用いたノイズのないシミュレータ上でテストを行い、回路がベル対を生成することを確認する [0, 1, 2, 3]。 回路の実行には、バックエンドモード Sampler``AerSimulator として IBM Quantum を使用しています。
ステップ1：古典的な入力を量子問題にマッピングする
まず、デバイスのトポロジーに合わせて調整された、すべての候補となるベル対リンクを評価するための量子回路セットを作成します。 [0, 1, 2, 3]まず、4量子ビットのチェーンを用いて、そのような回路を構築することから始めます。
この create_bell_stab() ルーチンは、各チェーンに対して以下の処理を行います：
- 中間ベル対を準備する：量子ビット1にハダマード演算を適用し、量子ビット1から量子ビット2へCNOTを適用する。 これにより量子ビット1と2がもつれ合う（ベル状態 を生成する）。
- 端の量子ビットを絡み合わせる：量子ビット0から量子ビット1へCNOTを適用し、量子ビット2から量子ビット3へCNOTを適用する。 これにより、当初分離していたペアが連結され、次のステップの後には量子ビット0と3がもつれ合う状態になる。 量子ビット2に対してハダマード変換も適用される（これは、前のCNOTと組み合わせて、量子ビット1と2に対するベル測定の一部を構成する）。 現時点では、量子ビット0と3はまだもつれていませんが、量子ビット1と2はより大きな4量子ビット状態においてそれらともつれています。
- 中間回路測定とフィードフォワード：量子ビット1と2（中間量子ビット）は計算基底で測定され、2つの古典ビットを生成する。 それらの測定結果に基づき、条件付き操作を適用する：量子ビット1の測定結果（これをビット と呼ぶ）が1の場合、量子ビット3にX ゲートを適用する；量子ビット2の測定結果（ ）が1の場合、量子ビット0にY ゲートを適用する。 これらの条件付きゲート（Qiskit
if_test/if_elseconstruct を使用して実現）は、標準的なテレポーテーション補正を実装する。 量子ビット1と2の投影によって生じるランダムなパウリの反転を「元に戻す」ことで、量子ビット0と3が測定結果にかかわらず既知のベル状態に収束することを保証する。 このステップの後、量子ビット0と3は理想的にはベル状態に絡み合 っているべきである。 - ベルペアスタビライザーの測定：その後、回路を2つのバージョンに分割します。 最初のバージョンでは、量子ビット0と3の スタビライザーを測定します。 第二のバージョンでは、これらの量子ビットに対して スタビライザーを測定する。
4量子ビットの初期配置ごとに、上記の関数は2つの回路を返します（1つは 用、もう1つは のスタビライザー測定用です）。 これらの回路には、回路中間での測定や条件分岐（if/else）演算が含まれており、これらは動的回路の主要な命令である。
from qiskit_aer import AerSimulator
# 4-qubit chain for simulation
sim_layout = [[0, 1, 2, 3]]
aer_backend = AerSimulator()
sim_circuits = create_bell_stab(sim_layout)
sim_circuits[1].draw("mpl", fold=-1, idle_wires=False)Output:
ステップ2：量子ハードウェア実行に向けた問題の最適化
回路を実行する前に、指定されたバックエンドでサポートされているゲート演算に変換する必要があります。 トランスパイレーションにより、抽象回路が選択されたバックエンドの物理量子ビットおよびゲートセットにマッピングされます。 各チェーンごとに具体的な物理量子ビットを（回路生成器に を initial_layout 指定することで）すでに選択しているため、その固定レイアウトを持つトランスパイラ optimization_level=0 を使用します。 これにより、Qiskitに対して、量子ビットの再割り当てを行わないよう、また回路構造を変更する可能性のある大規模な最適化を実行しないよう指示します。 操作の順序（特に条件ゲート）を、指定どおりに厳密に維持したいと考えています。
pm_sim = generate_preset_pass_manager(
optimization_level=0, backend=aer_backend, initial_layout=sim_layout[0]
)
isa_sim_circuits = pm_sim.run(sim_circuits)
isa_sim_circuits[1].draw("mpl", fold=-1, idle_wires=False)ステップ3: Qiskit primitivesを使用して実行する
これで、ノイズのないシミュレータバックエンド上で実験を実行できるようになりました。
# Run on noiseless simulator
sampler_sim = Sampler(mode=aer_backend)
sim_job = sampler_sim.run(isa_sim_circuits)
sim_mse = get_mse(sim_job.result(), sim_layout)Output:
layout [0, 1, 2, 3]
qubits: [0, 1, 2, 3], mse:, 0.0
ステップ4：後処理を行い、結果を望ましい古典的な形式で返す
最終ステップとして、テスト対象の各量子ビットグループについて二乗誤差平均（MSE）を計算し、結果をまとめる。 各チェーンについて、測定された と が 得られた。量子ビット0と3が 完全なベル状態に絡み合っていた場合、これら両方が+1となることが予想される。 誤差をMSEを用いて定量化する：
完全なベル対の場合、この値は0となりますが、量子もつれ状態のノイズが増加するにつれて値は大きくなります（ランダムな結果の期待値が0付近にある場合、MSEは1に近づきます）。 このコードは、4量子ビットのグループごとにこのMSEを計算します。 ノイズがないため、この小規模なシミュレータの例では、予想通りMSEが0となることがわかります。
大規模なハードウェアの例
ここで、これらすべての詳細を統合し、より大規模な単一のワークフローとしてまとめ、それを実際の量子ハードウェア上で実行します。
service = QiskitRuntimeService()
backend = service.least_busy(operational=True)デバイス結合マップをプログラムで探索し、4つの量子ビットからなるすべての直列接続チェーンを抽出します。 このような各連鎖（量子ビットの添字 で表される）は、エンタングルメント交換回路のテストケースとして機能する。 length-4 のすべての可能な経路を特定することで、プロトコルを実現し得る量子ビットのグループ分けについて、最大限の網羅性を確保します。
これらのチェーンは、デバイスグラフに対して貪欲探索を行うヘルパー関数を使用して生成します。 4つの4量子ビット鎖を束ねて16量子ビットのグループにした「ストリップ」を返す。 バンドリングにより、チップの異なる領域で複数の4量子ビット実験を並行して実行し、デバイス全体を効率的に活用することが可能になります。 各16キュービットのストライプには4つの互いに交わらないチェーンが含まれており、つまりそのグループ内ではどのキュービットも重複して使用されない。 たとえば、1つのストライプは、 、 、 、 の各チェーンをまとめてパッケージ化したもので構成される場合があります。 leftover ストライプに含まれていなかったクビットは、変数に返されます。
from itertools import chain
from collections import defaultdict
def stripes16_from_backend(backend):
"""
Creates stripes of 16 qubits, four non-overlapping
four-qubit chains, that cover as much of the coupling
map as possible. Returns any unused qubits as leftovers.
"""
# get the undirected adjacency list
edges = backend.coupling_map.get_edges()
graph = defaultdict(set)
for u, v in edges:
graph[u].add(v)
graph[v].add(u)
qubits = sorted(graph) # all qubit indices that appear
# greedy search for 4-long linear chains (blocks) ────────────
used = set() # qubits already placed in a block
blocks = [] # each block is a four-qubit list
for q in qubits: # deterministic order for reproducibility
if q in used:
continue # already consumed by earlier block
# depth-first "straight" walk of length 3 without revisiting nodes
def extend(path):
if len(path) == 4:
return path
tip = path[-1]
for nbr in sorted(graph[tip]): # deterministic
if nbr not in path and nbr not in used:
maybe = extend(path + [nbr])
if maybe:
return maybe
return None
block = extend([q])
if block: # found a 4-node path
blocks.append(block)
used.update(block)
# bundle four four-qubit blocks into one 16-qubit
# stripe (max number of measurement compatible with if-else)
stripes = [
list(chain.from_iterable(blocks[i : i + 4]))
for i in range(0, len(blocks) // 4 * 4, 4) # full groups of four
]
leftovers = set(qubits) - set(chain.from_iterable(stripes))
return stripes, leftoversinitial_layouts, leftover = stripes16_from_backend(backend)create_bell_stab()次に、関数 を用いて、各16量子ビットのストライプに対応する回路を構築する。 このステップの終了時点で、デバイス上のすべての4量子ビットチェーンを網羅する回路のリストが得られます。 その後、回路をトランスパイルして実際のバックエンド上で実行し、結果に対して後処理を行います。
# -------------------------Step 1-------------------------
circuits = create_bell_stab(initial_layouts)
# -------------------------Step 2-------------------------
isa_circuits = []
for ind, init_layout in enumerate(initial_layouts):
pm = generate_preset_pass_manager(
optimization_level=0, backend=backend, initial_layout=init_layout
)
isa_circ = pm.run(circuits[ind * 2 : ind * 2 + 2])
isa_circuits.extend(isa_circ)
isa_circuits[1].draw("mpl", fold=-1, idle_wires=False)
# -------------------------Step 3-------------------------
sampler = Sampler(mode=backend)
sampler.options.environment.job_tags = ["TUT_BDC"]
job = sampler.run(isa_circuits)
# -------------------------Step 4-------------------------
layouts_mse = get_mse(job.result(), initial_layouts)Output:
layout [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
qubits: [0, 1, 2, 3], mse:, 0.6302
qubits: [4, 5, 6, 7], mse:, 0.0949
qubits: [8, 9, 10, 11], mse:, 0.1729
qubits: [12, 13, 14, 15], mse:, 0.0473
layout [16, 23, 22, 21, 17, 27, 26, 25, 18, 31, 30, 29, 19, 35, 34, 33]
qubits: [16, 23, 22, 21], mse:, 0.0533
qubits: [17, 27, 26, 25], mse:, 0.2966
qubits: [18, 31, 30, 29], mse:, 0.0447
qubits: [19, 35, 34, 33], mse:, 0.0392
layout [36, 41, 42, 43, 37, 45, 46, 47, 38, 49, 50, 51, 39, 53, 54, 55]
qubits: [36, 41, 42, 43], mse:, 0.1577
qubits: [37, 45, 46, 47], mse:, 0.0705
qubits: [38, 49, 50, 51], mse:, 0.2914
qubits: [39, 53, 54, 55], mse:, 0.1711
layout [56, 63, 62, 61, 57, 67, 66, 65, 58, 71, 70, 69, 59, 75, 74, 73]
qubits: [56, 63, 62, 61], mse:, 0.1236
qubits: [57, 67, 66, 65], mse:, 0.9969
qubits: [58, 71, 70, 69], mse:, 0.0631
qubits: [59, 75, 74, 73], mse:, 0.0301
layout [76, 81, 82, 83, 77, 85, 86, 87, 78, 89, 90, 91, 79, 93, 94, 95]
qubits: [76, 81, 82, 83], mse:, 0.2787
qubits: [77, 85, 86, 87], mse:, 0.0497
qubits: [78, 89, 90, 91], mse:, 0.1271
qubits: [79, 93, 94, 95], mse:, 0.0468
layout [96, 103, 102, 101, 97, 107, 106, 105, 98, 111, 110, 109, 99, 115, 114, 113]
qubits: [96, 103, 102, 101], mse:, 0.8657
qubits: [97, 107, 106, 105], mse:, 0.0399
qubits: [98, 111, 110, 109], mse:, 0.0667
qubits: [99, 115, 114, 113], mse:, 0.2444
layout [116, 121, 122, 123, 117, 125, 126, 127, 118, 129, 130, 131, 119, 133, 134, 135]
qubits: [116, 121, 122, 123], mse:, 0.0429
qubits: [117, 125, 126, 127], mse:, 0.0487
qubits: [118, 129, 130, 131], mse:, 0.0823
qubits: [119, 133, 134, 135], mse:, 0.0583
layout [136, 143, 142, 141, 137, 147, 146, 145, 138, 151, 150, 149, 139, 155, 154, 153]
qubits: [136, 143, 142, 141], mse:, 0.0209
qubits: [137, 147, 146, 145], mse:, 0.0384
qubits: [138, 151, 150, 149], mse:, 0.4941
qubits: [139, 155, 154, 153], mse:, 0.1062
結果から、デバイス全体でエンタングルメントの品質に幅広いばらつきが明らかになった。 この結果は、使用する物理量子ビットによってベル状態の忠実度が1桁以上変動し得るという本論文の知見を裏付けるものである。 実用的な観点から言えば、これはチップ内の特定の領域や接続が、他の領域や接続よりも回路中間測定やフィードフォワード演算をはるかに効率的に実行できることを意味する。 量子ビットの読み出し誤差、量子ビットの寿命、クロストークなどの要因が、これらの差異に寄与している可能性が高い。 例えば、あるチェーンに特にノイズの多い読み出し量子ビットが含まれている場合、回路中盤での測定が信頼性を欠く可能性があり、その結果、そのエンタングルメントペアの忠実度が低下する（MSEが高くなる）。
最後に、すべてのチェーンのMSE値の累積分布関数（CDF）をプロットすることで、全体的な性能を可視化する。 CDFプロットは、x軸にMSE閾値、y軸にそのMSE以下となる量子ビットペアの割合を示しています。 この曲線はゼロから始まり、閾値がすべてのデータポイントを包含するように大きくなるにつれて1に近づく。 低いMSE付近での急な上昇は、多くのペアが高精度であることを示唆する。緩やかな上昇は、多くのペアに大きな誤差があることを意味する。 CDFに最適なペアの識別情報を注釈として付与する。 プロットでは、累積分布関数（CDF）上の各点が1つの4量子ビット鎖の二乗誤差（MSE）に対応し、その実験でエンタングルメントが生じた量子ビットのペアの インデックスで点をラベル付けする。 これにより、どの物理量子ビットペアが最高のパフォーマンスを発揮しているか（CDFの左端の点）を容易に特定できます。
plot_mse_ecdfs(layouts_mse, combine_layouts=True)Output:
次のステップ
この作品に興味を持たれた方は、以下の資料もご参照ください：
- 動的回路を用いた長距離エンタングルメントの実装方法を学ぶ
- 動的回路を用いて、キック付きアイジング・ハミルトニアンをシミュレートする方法を学びましょう
参照
[1] カレラ・バスケス, A., トルノー, C., Ristè, D. ほか 量子プロセッサとリアルタイムの古典的通信を組み合わせる。 『Nature』636号、75-79頁（2024年）。