第4章：超伝導量子デバイス

学習目標

1. 超伝導量子ビットの種類

1.1 量子ビットの基本概念

超伝導量子ビットは、非線形LC振動子として動作するJosephson接合ベースの回路です。 これらは量子コンピューティングにおける最も有望な量子ビット実装の一つであり、 その設計可能性、スケーラビリティ、そして急速に向上するコヒーレンス時間により、多くの利点を提供します。

1.2 Charge量子ビット（Cooper対ボックス）

Cooper対ボックスは、小さなキャパシタンス$C$の超伝導島とゲート電圧$V_g$（ゲートキャパシタンス$C_g$を介して） を持つ、Josephson接合（$E_J$）によって電極に接続されたシステムです。

Hamiltonian：

ここで：

• $E_C = \frac{e^2}{2C_{\Sigma}}$ は帯電エネルギー（$C_{\Sigma} = C + C_g$）
• $\hat{n}$ は島上のCooper対数演算子
• $n_g = C_g V_g / (2e)$ は無次元ゲート電荷
• $\hat{\phi}$ は位相差演算子

charge量子ビットは、$E_J \ll E_C$の regime で動作します。計算基底は、 異なるCooper対数の状態 $|0\rangle$ と $|1\rangle$ で構成されます。

1.3 Transmon量子ビット

Transmonは、$E_J/E_C$比を大きくすることで電荷ノイズに対する感度を指数関数的に抑制します。 これはより大きなキャパシタンス（小さな$E_C$）とより大きな$E_J$を使用することで達成されます。

エネルギースペクトル：

$E_J/E_C \gg 1$の極限で、エネルギー準位はおおよそ次のように表されます：

非調和性（anharmonicity）は次のように定義されます：

この負の非調和性により、$|0\rangle \leftrightarrow |1\rangle$ 遷移に選択的に駆動をかけることができ、 高励起状態への漏れを最小限に抑えることができます。

import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import eigh

def transmon_hamiltonian(n_max, EJ, EC):
    """
    Transmon Hamiltonianを電荷基底で構築

    Parameters:
    -----------
    n_max : int
        最大電荷数
    EJ : float
        Josephsonエネルギー (GHz)
    EC : float
        帯電エネルギー (GHz)

    Returns:
    --------
    energies : array
        固有エネルギー (GHz)
    states : array
        固有状態
    """
    # 電荷状態の数
    n_states = 2 * n_max + 1

    # Hamiltonianを初期化
    H = np.zeros((n_states, n_states))

    # 対角要素: 帯電エネルギー
    for i, n in enumerate(range(-n_max, n_max + 1)):
        H[i, i] = 4 * EC * n**2

    # オフ対角要素: Josephsonエネルギー
    for i in range(n_states - 1):
        H[i, i+1] = -EJ / 2
        H[i+1, i] = -EJ / 2

    # Hamiltonianを対角化
    energies, states = eigh(H)

    # エネルギーを基底状態から測定
    energies -= energies[0]

    return energies, states

# パラメータ
n_max = 10
EJ = 20.0  # GHz
EC_values = np.linspace(0.1, 1.0, 50)  # GHz

# 各ECに対する遷移エネルギーを計算
E01_list = []
E12_list = []
anharmonicity_list = []

for EC in EC_values:
    energies, _ = transmon_hamiltonian(n_max, EJ, EC)
    E01 = energies[1] - energies[0]
    E12 = energies[2] - energies[1]
    alpha = E12 - E01

    E01_list.append(E01)
    E12_list.append(E12)
    anharmonicity_list.append(alpha)

# プロット
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# 遷移エネルギー
ax1.plot(EC_values, E01_list, 'b-', linewidth=2, label=r'$E_{01}$')
ax1.plot(EC_values, E12_list, 'r-', linewidth=2, label=r'$E_{12}$')
ax1.set_xlabel(r'$E_C$ (GHz)', fontsize=12)
ax1.set_ylabel('遷移エネルギー (GHz)', fontsize=12)
ax1.set_title(r'Transmon遷移エネルギー ($E_J = 20$ GHz)', fontsize=13)
ax1.legend(fontsize=11)
ax1.grid(True, alpha=0.3)

# 非調和性
ax2.plot(EC_values, anharmonicity_list, 'g-', linewidth=2)
ax2.axhline(y=0, color='k', linestyle='--', alpha=0.5)
ax2.set_xlabel(r'$E_C$ (GHz)', fontsize=12)
ax2.set_ylabel(r'非調和性 $\alpha = E_{12} - E_{01}$ (GHz)', fontsize=12)
ax2.set_title('Transmon非調和性', fontsize=13)
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('transmon_spectrum.png', dpi=300, bbox_inches='tight')
plt.show()

# 特定のECでのエネルギーレベル
EC_example = 0.3  # GHz
energies_example, _ = transmon_hamiltonian(n_max, EJ, EC_example)

print(f"Transmonパラメータ: EJ = {EJ} GHz, EC = {EC_example} GHz")
print(f"EJ/EC比 = {EJ/EC_example:.2f}")
print(f"\n最初の6つのエネルギーレベル (GHz):")
for i in range(6):
    print(f"  E{i} = {energies_example[i]:.4f}")
print(f"\n遷移周波数:")
print(f"  ω01 = {energies_example[1] - energies_example[0]:.4f} GHz")
print(f"  ω12 = {energies_example[2] - energies_example[1]:.4f} GHz")
print(f"非調和性 α = {(energies_example[2] - energies_example[1]) - (energies_example[1] - energies_example[0]):.4f} GHz")

Transmonパラメータ: EJ = 20 GHz, EC = 0.3 GHz
EJ/EC比 = 66.67

最初の6つのエネルギーレベル (GHz):
  E0 = 0.0000
  E1 = 4.7916
  E2 = 9.2832
  E3 = 13.4748
  E4 = 17.3664
  E5 = 20.9580

遷移周波数:
  ω01 = 4.7916 GHz
  ω12 = 4.4916 GHz
非調和性 α = -0.3000 GHz

1.4 Flux量子ビット

Flux量子ビットは、3つのJosephson接合を持つ超伝導ループで構成され、 外部磁束によってバイアスされます。量子ビット状態は、ループ内の異なる磁束方向に対応します。

ポテンシャルエネルギー：

ここで、$\delta$は位相差、$\Phi_{\text{ext}}$は外部磁束、$\Phi_0 = h/(2e)$は磁束量子です。

フラストレーション点（$\Phi_{\text{ext}} = \Phi_0/2$）近傍で、ポテンシャルは二重井戸を形成し、 計算基底は左回りおよび右回りの永久電流状態 $|L\rangle$ と $|R\rangle$ になります。

1.5 Fluxonium量子ビット

Fluxoniumは、Josephson接合を大きなインダクタンス（通常はJosephson接合アレイ）と シャントするように設計された比較的新しい量子ビット設計です。

Hamiltonian：

ここで、$E_L = (\Phi_0/2\pi)^2/L$はインダクティブエネルギーです。

大きなインダクタンス（小さな$E_L$）により、fluxoniumは優れた電荷および磁束ノイズ保護を実現し、 ミリ秒のオーダーのコヒーレンス時間を可能にします。

2. 回路量子電磁力学（Circuit QED）

2.1 cQEDの基本概念

回路量子電磁力学（cQED）は、キャビティ量子電磁力学の原理を超伝導回路に適用したものです。 量子ビット（人工原子）を超伝導共振器（マイクロ波キャビティ）に結合させることで、 量子情報処理、量子測定、および量子ビット間の相互作用を実現します。

Jaynes-Cummings Hamiltonian：

ここで：

• $\omega_q$ は量子ビット周波数
• $\omega_r$ は共振器周波数
• $g$ は量子ビット-共振器結合強度
• $\hat{a}$, $\hat{a}^\dagger$ は共振器の消滅・生成演算子
• $\hat{\sigma}_\pm$ は量子ビットの昇降演算子

2.2 Dispersive Regime

大きなデチューニング $|\Delta| = |\omega_q - \omega_r| \gg g$ の場合、 システムはdispersive regimeで動作します。

Dispersive Hamiltonian：

ここで、$\chi = g^2/\Delta$はdispersive shiftです。

このregimeでは、共振器周波数は量子ビット状態に依存します：

この状態依存性により、量子ビット状態の量子非破壊（QND）測定が可能になります。

import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import expm

def jaynes_cummings_hamiltonian(omega_q, omega_r, g, n_levels=5):
    """
    Jaynes-Cummings Hamiltonianを構築

    Parameters:
    -----------
    omega_q : float
        量子ビット周波数 (GHz)
    omega_r : float
        共振器周波数 (GHz)
    g : float
        結合強度 (GHz)
    n_levels : int
        共振器のFock状態数

    Returns:
    --------
    H : array
        Hamiltonian行列 (2*n_levels × 2*n_levels)
    """
    dim = 2 * n_levels  # 量子ビット(2レベル) × 共振器(n_levels)
    H = np.zeros((dim, dim), dtype=complex)

    # 量子ビットと共振器の固有エネルギー
    for n in range(n_levels):
        # |g,n⟩ 状態
        H[2*n, 2*n] = -omega_q/2 + n * omega_r
        # |e,n⟩ 状態
        H[2*n+1, 2*n+1] = omega_q/2 + n * omega_r

    # 相互作用項 (回転波近似)
    for n in range(n_levels - 1):
        # σ+ a (|g,n+1⟩ → |e,n⟩)
        H[2*n+1, 2*n+2] = g * np.sqrt(n + 1)
        # σ- a† (|e,n⟩ → |g,n+1⟩)
        H[2*n+2, 2*n+1] = g * np.sqrt(n + 1)

    return H

def time_evolution_jc(H, psi0, t_max, n_points=500):
    """
    Jaynes-Cummingsモデルの時間発展を計算

    Parameters:
    -----------
    H : array
        Hamiltonian
    psi0 : array
        初期状態
    t_max : float
        最大時間 (ns)
    n_points : int
        時間点の数

    Returns:
    --------
    times : array
        時間配列
    populations : array
        状態占有率の時間発展
    """
    times = np.linspace(0, t_max, n_points)
    populations = np.zeros((len(times), len(psi0)))

    for i, t in enumerate(times):
        # 時間発展演算子を適用
        U = expm(-1j * H * t)
        psi_t = U @ psi0
        populations[i] = np.abs(psi_t)**2

    return times, populations

# パラメータ（典型的なTransmon-共振器システム）
omega_q = 5.0  # GHz
omega_r = 6.0  # GHz
g = 0.1  # GHz
n_levels = 5

# Hamiltonianを構築
H = jaynes_cummings_hamiltonian(omega_q, omega_r, g, n_levels)

# 初期状態: |e,0⟩ (励起量子ビット、共振器は真空)
psi0 = np.zeros(2 * n_levels)
psi0[1] = 1.0  # |e,0⟩

# 時間発展を計算
t_max = 100  # ns
times, populations = time_evolution_jc(H, psi0, t_max)

# プロット
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))

# 量子ビット状態の占有率
qubit_excited = np.sum(populations[:, 1::2], axis=1)  # すべての |e,n⟩
qubit_ground = np.sum(populations[:, 0::2], axis=1)   # すべての |g,n⟩

ax1.plot(times, qubit_excited, 'r-', linewidth=2, label='励起状態 |e⟩')
ax1.plot(times, qubit_ground, 'b-', linewidth=2, label='基底状態 |g⟩')
ax1.set_xlabel('時間 (ns)', fontsize=12)
ax1.set_ylabel('量子ビット占有率', fontsize=12)
ax1.set_title('Jaynes-Cummings振動：量子ビット状態', fontsize=13)
ax1.legend(fontsize=11)
ax1.grid(True, alpha=0.3)
ax1.set_ylim([0, 1.05])

# 共振器のFock状態占有率
for n in range(n_levels):
    photon_n = populations[:, 2*n] + populations[:, 2*n+1]
    ax2.plot(times, photon_n, linewidth=2, label=f'n={n}光子')

ax2.set_xlabel('時間 (ns)', fontsize=12)
ax2.set_ylabel('共振器Fock状態占有率', fontsize=12)
ax2.set_title('Jaynes-Cummings振動：共振器光子数', fontsize=13)
ax2.legend(fontsize=10)
ax2.grid(True, alpha=0.3)
ax2.set_ylim([0, 1.05])

plt.tight_layout()
plt.savefig('jaynes_cummings_dynamics.png', dpi=300, bbox_inches='tight')
plt.show()

# 真空Rabi周波数を計算
Delta = omega_q - omega_r
Omega_vac = 2 * g
print(f"\ncQEDパラメータ:")
print(f"  量子ビット周波数: ωq = {omega_q} GHz")
print(f"  共振器周波数: ωr = {omega_r} GHz")
print(f"  デチューニング: Δ = {Delta} GHz")
print(f"  結合強度: g = {g} GHz")
print(f"  真空Rabi周波数: Ωvac = {Omega_vac} GHz")
print(f"  真空Rabi周期: Tvac = {1/Omega_vac:.2f} ns")
print(f"  Dispersive shift: χ = {g**2/Delta:.4f} GHz")

cQEDパラメータ:
  量子ビット周波数: ωq = 5.0 GHz
  共振器周波数: ωr = 6.0 GHz
  デチューニング: Δ = -1.0 GHz
  結合強度: g = 0.1 GHz
  真空Rabi周波数: Ωvac = 0.2 GHz
  真空Rabi周期: Tvac = 5.00 ns
  Dispersive shift: χ = 0.0100 GHz

2.3 量子ビット読み出し

Dispersive regimeでは、共振器の透過または反射信号を測定することで量子ビット状態を読み出します。 測定プロトコル：

1. 共振器にマイクロ波トーン（$\omega_{\text{probe}} \approx \omega_r'$）を印加
2. 透過/反射信号の振幅と位相を測定
3. 信号は量子ビット状態に依存（$\chi$による周波数シフトのため）
4. 信号を閾値判定して量子ビット状態を決定

3. 量子ビットのコヒーレンスとデコヒーレンス

3.1 コヒーレンス時間

量子ビットの性能を特徴づける主要な時間スケール：

• $T_1$（エネルギー緩和時間）：励起状態の寿命
• $T_2$（位相コヒーレンス時間）：重ね合わせ状態のコヒーレンスの寿命
• $T_2^*$（純粋デフェージング時間からの寄与を含む）

一般的な関係：

ここで、$T_\phi$は純粋デフェージング時間です。

3.2 主要なデコヒーレンス機構

3.3 デコヒーレンスの軽減戦略

• 材料改善：高品質基板、低損失誘電体
• デザイン最適化：Transmon（電荷ノイズ低減）、Fluxonium（両方のノイズに対する保護）
• 環境制御：極低温動作、磁気シールド
• 動的デカップリング：パルスシーケンスでノイズを平均化
• 量子誤り訂正：冗長符号化とアクティブエラー訂正

import numpy as np
import matplotlib.pyplot as plt

def bloch_equations_with_decoherence(u, v, w, omega_drive, delta, T1, T2):
    """
    デコヒーレンスを含むBloch方程式

    Parameters:
    -----------
    u, v, w : float
        Blochベクトル成分（回転フレーム）
    omega_drive : float
        駆動強度 (Rabi周波数)
    delta : float
        デチューニング
    T1, T2 : float
        緩和時間

    Returns:
    --------
    dudt, dvdt, dwdt : float
        時間微分
    """
    dudt = delta * v - u / T2
    dvdt = -delta * u + omega_drive * w - v / T2
    dwdt = -omega_drive * v - (w + 1) / T1

    return dudt, dvdt, dwdt

def runge_kutta_4(func, y0, t, args):
    """4次ルンゲ=クッタ法"""
    dt = t[1] - t[0]
    y = np.zeros((len(t), len(y0)))
    y[0] = y0

    for i in range(len(t) - 1):
        k1 = np.array(func(*y[i], *args))
        k2 = np.array(func(*(y[i] + dt/2 * k1), *args))
        k3 = np.array(func(*(y[i] + dt/2 * k2), *args))
        k4 = np.array(func(*(y[i] + dt * k3), *args))

        y[i+1] = y[i] + dt/6 * (k1 + 2*k2 + 2*k3 + k4)

    return y

# パラメータ
T1 = 50.0  # μs
T2 = 30.0  # μs (T2 < 2*T1)
omega_drive = 0.0  # 駆動なし（自由緩和）
delta = 0.0  # 共鳴

# 時間配列
t = np.linspace(0, 150, 1500)  # μs

# ケース1：励起状態からのエネルギー緩和
y0_excited = [0, 0, 1]  # |e⟩ 状態 (w = +1)
sol_T1 = runge_kutta_4(bloch_equations_with_decoherence, y0_excited, t,
                       (omega_drive, delta, T1, T2))

# ケース2：重ね合わせ状態のデフェージング
y0_superposition = [1, 0, 0]  # (|g⟩ + |e⟩)/√2 (u = +1)
sol_T2 = runge_kutta_4(bloch_equations_with_decoherence, y0_superposition, t,
                       (omega_drive, delta, T1, T2))

# プロット
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(14, 10))

# T1緩和：w成分
ax1.plot(t, sol_T1[:, 2], 'b-', linewidth=2, label='シミュレーション')
ax1.plot(t, np.exp(-t/T1), 'r--', linewidth=2, label=f'exp(-t/T₁), T₁={T1} μs')
ax1.set_xlabel('時間 (μs)', fontsize=12)
ax1.set_ylabel('w (集団反転)', fontsize=12)
ax1.set_title('エネルギー緩和 (T₁過程)', fontsize=13)
ax1.legend(fontsize=11)
ax1.grid(True, alpha=0.3)

# T1緩和：集団
P_excited_T1 = (sol_T1[:, 2] + 1) / 2
P_ground_T1 = 1 - P_excited_T1
ax2.plot(t, P_excited_T1, 'r-', linewidth=2, label='|e⟩')
ax2.plot(t, P_ground_T1, 'b-', linewidth=2, label='|g⟩')
ax2.set_xlabel('時間 (μs)', fontsize=12)
ax2.set_ylabel('状態占有率', fontsize=12)
ax2.set_title('T₁緩和：状態占有率', fontsize=13)
ax2.legend(fontsize=11)
ax2.grid(True, alpha=0.3)

# T2デフェージング：u成分
ax3.plot(t, sol_T2[:, 0], 'b-', linewidth=2, label='シミュレーション')
ax3.plot(t, np.exp(-t/T2), 'r--', linewidth=2, label=f'exp(-t/T₂), T₂={T2} μs')
ax3.set_xlabel('時間 (μs)', fontsize=12)
ax3.set_ylabel('u (コヒーレンス)', fontsize=12)
ax3.set_title('位相コヒーレンス減衰 (T₂過程)', fontsize=13)
ax3.legend(fontsize=11)
ax3.grid(True, alpha=0.3)

# Blochベクトルの大きさ
r_T1 = np.sqrt(sol_T1[:, 0]**2 + sol_T1[:, 1]**2 + sol_T1[:, 2]**2)
r_T2 = np.sqrt(sol_T2[:, 0]**2 + sol_T2[:, 1]**2 + sol_T2[:, 2]**2)
ax4.plot(t, r_T1, 'b-', linewidth=2, label='T₁緩和ケース')
ax4.plot(t, r_T2, 'r-', linewidth=2, label='T₂デフェージングケース')
ax4.axhline(y=1, color='k', linestyle='--', alpha=0.5, label='純粋状態')
ax4.set_xlabel('時間 (μs)', fontsize=12)
ax4.set_ylabel('|r| (Blochベクトル長)', fontsize=12)
ax4.set_title('デコヒーレンス：状態純度の喪失', fontsize=13)
ax4.legend(fontsize=11)
ax4.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('decoherence_dynamics.png', dpi=300, bbox_inches='tight')
plt.show()

print(f"デコヒーレンスパラメータ:")
print(f"  T₁ (エネルギー緩和時間) = {T1} μs")
print(f"  T₂ (位相コヒーレンス時間) = {T2} μs")
print(f"  T₂ の上限 (2T₁) = {2*T1} μs")
print(f"  純粋デフェージング時間 Tφ = {1/(1/T2 - 1/(2*T1)):.2f} μs")

デコヒーレンスパラメータ:
  T₁ (エネルギー緩和時間) = 50.0 μs
  T₂ (位相コヒーレンス時間) = 30.0 μs
  T₂ の上限 (2T₁) = 100.0 μs
  純粋デフェージング時間 Tφ = 75.00 μs

4. 量子ゲートと量子アルゴリズム

4.1 単一量子ビットゲート

単一量子ビットゲートは、マイクロ波パルスを量子ビットに印加することで実装されます。

回転ゲート：

一般的な単一量子ビット演算は、これらの回転の組み合わせで構成できます：

4.2 2量子ビットゲート

CNOT（制御NOT）ゲート：

超伝導量子ビットでは、CNOTゲートは通常、可変結合を持つCross-resonance駆動または 調整可能な量子ビット周波数を使用して実装されます。

iSWAPゲート：

これは、結合された量子ビット間の交換相互作用から自然に生じます。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyBboxPatch

# Pauli行列と基本ゲート
I = np.array([[1, 0], [0, 1]], dtype=complex)
X = np.array([[0, 1], [1, 0]], dtype=complex)
Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
Z = np.array([[1, 0], [0, -1]], dtype=complex)

def Rx(theta):
    """X軸周りの回転"""
    return np.cos(theta/2)*I - 1j*np.sin(theta/2)*X

def Ry(theta):
    """Y軸周りの回転"""
    return np.cos(theta/2)*I - 1j*np.sin(theta/2)*Y

def Rz(phi):
    """Z軸周りの回転"""
    return np.array([[np.exp(-1j*phi/2), 0],
                     [0, np.exp(1j*phi/2)]], dtype=complex)

# Hadamardゲート
H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]], dtype=complex)

# CNOTゲート（2量子ビット）
CNOT = np.array([[1, 0, 0, 0],
                 [0, 1, 0, 0],
                 [0, 0, 0, 1],
                 [0, 0, 1, 0]], dtype=complex)

def tensor_product(A, B):
    """テンソル積（クロネッカー積）"""
    return np.kron(A, B)

def apply_gate(gate, state):
    """状態にゲートを適用"""
    return gate @ state

def measure_state(state, num_shots=1000):
    """状態を測定（確率的サンプリング）"""
    probabilities = np.abs(state)**2
    n_qubits = int(np.log2(len(state)))

    # 計算基底での測定結果をサンプリング
    basis_states = [format(i, f'0{n_qubits}b') for i in range(len(state))]
    measurements = np.random.choice(basis_states, size=num_shots, p=probabilities)

    # 各基底状態の出現回数をカウント
    counts = {basis: 0 for basis in basis_states}
    for m in measurements:
        counts[m] += 1

    return counts

# ベル状態回路のシミュレーション
print("=== ベル状態（最大エンタングル状態）の生成 ===\n")

# 初期状態 |00⟩
psi_0 = np.array([1, 0, 0, 0], dtype=complex)
print("初期状態 |00⟩:")
print(f"  状態ベクトル: {psi_0}\n")

# ステップ1: 最初の量子ビットにHadamardを適用
H_I = tensor_product(H, I)
psi_1 = apply_gate(H_I, psi_0)
print("Hadamard適用後 (H ⊗ I)|00⟩:")
print(f"  状態ベクトル: {psi_1}")
print(f"  = (|00⟩ + |10⟩)/√2\n")

# ステップ2: CNOTを適用
psi_bell = apply_gate(CNOT, psi_1)
print("CNOT適用後（ベル状態）:")
print(f"  状態ベクトル: {psi_bell}")
print(f"  = (|00⟩ + |11⟩)/√2")
print(f"  これはΦ⁺ベル状態です\n")

# 測定シミュレーション
counts = measure_state(psi_bell, num_shots=10000)
print("測定結果 (10000ショット):")
for basis, count in counts.items():
    if count > 0:
        print(f"  |{basis}⟩: {count} ({count/10000*100:.2f}%)")

# プロット：測定結果のヒストグラム
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# 測定統計
basis_labels = ['00', '01', '10', '11']
measurement_counts = [counts[b] for b in basis_labels]
colors = ['#3498db' if c > 0 else '#ecf0f1' for c in measurement_counts]

ax1.bar(basis_labels, measurement_counts, color=colors, edgecolor='black', linewidth=1.5)
ax1.set_xlabel('基底状態', fontsize=12)
ax1.set_ylabel('測定カウント', fontsize=12)
ax1.set_title('ベル状態Φ⁺の測定統計 (10000ショット)', fontsize=13)
ax1.grid(True, alpha=0.3, axis='y')

# 回路図（テキストベース表現）
ax2.axis('off')
ax2.set_xlim(0, 10)
ax2.set_ylim(0, 4)

# 量子ビット線
ax2.plot([1, 9], [3, 3], 'k-', linewidth=2)
ax2.plot([1, 9], [1, 1], 'k-', linewidth=2)
ax2.text(0.5, 3, 'q₀:', fontsize=14, va='center', ha='right', fontweight='bold')
ax2.text(0.5, 1, 'q₁:', fontsize=14, va='center', ha='right', fontweight='bold')

# 初期状態
ax2.text(1.5, 3, '|0⟩', fontsize=12, va='center', ha='center',
         bbox=dict(boxstyle='round,pad=0.3', facecolor='white', edgecolor='black'))
ax2.text(1.5, 1, '|0⟩', fontsize=12, va='center', ha='center',
         bbox=dict(boxstyle='round,pad=0.3', facecolor='white', edgecolor='black'))

# Hadamardゲート
rect_H = FancyBboxPatch((3.5, 2.6), 1, 0.8, boxstyle='round,pad=0.05',
                         edgecolor='blue', facecolor='lightblue', linewidth=2)
ax2.add_patch(rect_H)
ax2.text(4, 3, 'H', fontsize=14, va='center', ha='center', fontweight='bold')

# CNOTゲート
ax2.plot([6, 6], [1, 3], 'b-', linewidth=2)
ax2.plot(6, 3, 'bo', markersize=12, markerfacecolor='blue')
ax2.plot(6, 1, 'o', markersize=18, markerfacecolor='white',
         markeredgecolor='blue', markeredgewidth=2)
ax2.plot([5.7, 6.3], [1, 1], 'b-', linewidth=2)
ax2.plot([6, 6], [0.7, 1.3], 'b-', linewidth=2)

# 最終状態
ax2.text(8, 2, r'(|00⟩+|11⟩)/√2', fontsize=11, va='center', ha='center',
         bbox=dict(boxstyle='round,pad=0.4', facecolor='lightyellow', edgecolor='orange', linewidth=2))

ax2.set_title('量子回路：ベル状態生成', fontsize=13, fontweight='bold')

plt.tight_layout()
plt.savefig('bell_state_circuit.png', dpi=300, bbox_inches='tight')
plt.show()

# 他のベル状態も生成可能
print("\n=== 4つのベル基底状態 ===")
bell_states = {
    'Φ⁺': (tensor_product(I, I) @ CNOT @ tensor_product(H, I)) @ psi_0,
    'Φ⁻': (tensor_product(I, I) @ CNOT @ tensor_product(H, I) @ tensor_product(Z, I)) @ psi_0,
    'Ψ⁺': (tensor_product(I, I) @ CNOT @ tensor_product(H, I) @ tensor_product(I, X)) @ psi_0,
    'Ψ⁻': (tensor_product(I, I) @ CNOT @ tensor_product(H, I) @ tensor_product(Z, X)) @ psi_0
}

for name, state in bell_states.items():
    print(f"{name}: {np.round(state, 3)}")

=== ベル状態（最大エンタングル状態）の生成 ===

初期状態 |00⟩:
  状態ベクトル: [1.+0.j 0.+0.j 0.+0.j 0.+0.j]

Hadamard適用後 (H ⊗ I)|00⟩:
  状態ベクトル: [0.707+0.j 0.+0.j 0.707+0.j 0.+0.j]
  = (|00⟩ + |10⟩)/√2

CNOT適用後（ベル状態）:
  状態ベクトル: [0.707+0.j 0.+0.j 0.+0.j 0.707+0.j]
  = (|00⟩ + |11⟩)/√2
  これはΦ⁺ベル状態です

測定結果 (10000ショット):
  |00⟩: 5023 (50.23%)
  |11⟩: 4977 (49.77%)

5. SQUID磁力計

5.1 DC SQUID

DC SQUID（Superconducting Quantum Interference Device）は、2つのJosephson接合を 並列に配置した超伝導ループで構成されます。これは極めて高感度な磁力計として機能します。

動作原理：

SQUIDループを貫通する磁束$\Phi$は、2つの接合を流れる臨界電流を変調します：

ここで、$I_{c0}$は各接合の臨界電流、$\Phi_0 = h/(2e) \approx 2.07 \times 10^{-15}$ Wb は磁束量子です。

電圧-磁束特性：

バイアス電流$I_b$を$I_c$より大きくすると、SQUIDは電圧状態に入り、 その電圧は磁束に対して周期的に変化します：

5.2 RF SQUID

RF SQUIDは単一のJosephson接合を持つ超伝導ループで、 RFタンク回路に結合されています。磁束変化はタンク回路の共振周波数を変調し、 これを検出します。

ポテンシャルエネルギー：

ここで、$L$はループのインダクタンスです。

5.3 SQUIDの応用

• 生体磁気測定：脳磁図（MEG）、心磁図（MCG）
• 地球物理学：地磁気異常検出
• 材料評価：非破壊検査
• 基礎物理学：重力波検出器、暗黒物質探索
• 量子コンピューティング：量子ビット読み出し増幅器

import numpy as np
import matplotlib.pyplot as plt

def dc_squid_critical_current(flux, Ic0):
    """
    DC SQUIDの磁束依存臨界電流

    Parameters:
    -----------
    flux : array
        磁束（Φ₀単位）
    Ic0 : float
        各接合の臨界電流 (μA)

    Returns:
    --------
    Ic : array
        全臨界電流
    """
    return 2 * Ic0 * np.abs(np.cos(np.pi * flux))

def dc_squid_voltage(flux, Ic0, Ib, Rn):
    """
    DC SQUIDの電圧-磁束特性（簡略化モデル）

    Parameters:
    -----------
    flux : array
        磁束（Φ₀単位）
    Ic0 : float
        各接合の臨界電流 (μA)
    Ib : float
        バイアス電流 (μA)
    Rn : float
        接合の常伝導抵抗 (Ω)

    Returns:
    --------
    V : array
        SQUID電圧 (μV)
    """
    Ic = dc_squid_critical_current(flux, Ic0)

    # 抵抗状態の電圧（RSJモデル）
    V = np.zeros_like(flux)
    mask = Ib > Ic
    V[mask] = Rn * np.sqrt(Ib**2 - Ic[mask]**2)

    return V

# パラメータ（典型的なDC SQUID）
Ic0 = 10.0  # μA
Rn = 10.0   # Ω
Ib_values = [5.0, 10.0, 15.0, 20.0]  # μA

# 磁束配列
flux = np.linspace(-2, 2, 1000)

# プロット
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(12, 12))

# 臨界電流の磁束変調
Ic = dc_squid_critical_current(flux, Ic0)
ax1.plot(flux, Ic, 'b-', linewidth=2.5)
ax1.axhline(y=0, color='k', linestyle='--', alpha=0.3)
ax1.set_xlabel(r'磁束 $\Phi/\Phi_0$', fontsize=12)
ax1.set_ylabel(r'臨界電流 $I_c$ (μA)', fontsize=12)
ax1.set_title(r'DC SQUID 臨界電流変調 ($I_{c0}$ = 10 μA)', fontsize=13)
ax1.grid(True, alpha=0.3)
ax1.set_xlim([-2, 2])

# 異なるバイアス電流での電圧-磁束特性
for Ib in Ib_values:
    V = dc_squid_voltage(flux, Ic0, Ib, Rn)
    ax2.plot(flux, V, linewidth=2, label=f'$I_b$ = {Ib} μA')

ax2.set_xlabel(r'磁束 $\Phi/\Phi_0$', fontsize=12)
ax2.set_ylabel('電圧 (μV)', fontsize=12)
ax2.set_title('DC SQUID 電圧-磁束特性', fontsize=13)
ax2.legend(fontsize=10)
ax2.grid(True, alpha=0.3)
ax2.set_xlim([-2, 2])

# 磁束感度（dV/dΦ）
Ib_optimal = 15.0  # μA
V_optimal = dc_squid_voltage(flux, Ic0, Ib_optimal, Rn)
dV_dflux = np.gradient(V_optimal, flux[1] - flux[0])

ax3.plot(flux, dV_dflux, 'r-', linewidth=2)
ax3.axhline(y=0, color='k', linestyle='--', alpha=0.3)
ax3.set_xlabel(r'磁束 $\Phi/\Phi_0$', fontsize=12)
ax3.set_ylabel(r'磁束-電圧変換係数 $\partial V/\partial\Phi$ (μV/$\Phi_0$)', fontsize=12)
ax3.set_title(f'SQUID磁束感度 ($I_b$ = {Ib_optimal} μA)', fontsize=13)
ax3.grid(True, alpha=0.3)
ax3.set_xlim([-2, 2])

plt.tight_layout()
plt.savefig('dc_squid_characteristics.png', dpi=300, bbox_inches='tight')
plt.show()

# 性能指標の計算
flux_quantum = 2.07e-15  # Wb
max_sensitivity = np.max(np.abs(dV_dflux))
flux_noise = 1e-6  # μΦ₀/√Hz（典型値）
voltage_noise = max_sensitivity * flux_noise

print("DC SQUID性能指標:")
print(f"  各接合の臨界電流: {Ic0} μA")
print(f"  接合抵抗: {Rn} Ω")
print(f"  最適バイアス電流: {Ib_optimal} μA")
print(f"  最大磁束-電圧変換係数: {max_sensitivity:.2f} μV/Φ₀")
print(f"  磁束量子: {flux_quantum*1e15:.2f} fWb")
print(f"  典型的な磁束ノイズ: {flux_noise} μΦ₀/√Hz")
print(f"  対応する電圧ノイズ: {voltage_noise:.4f} μV/√Hz")
print(f"  磁場感度: ~{flux_quantum/1e-12:.2e} fT/√Hz (1 μm² SQUIDの場合)")

DC SQUID性能指標:
  各接合の臨界電流: 10.0 μA
  接合抵抗: 10.0 Ω
  最適バイアス電流: 15.0 μA
  最大磁束-電圧変換係数: 88.62 μV/Φ₀
  磁束量子: 2.07 fWb
  典型的な磁束ノイズ: 1e-06 μΦ₀/√Hz
  対応する電圧ノイズ: 0.0001 μV/√Hz
  磁場感度: ~2.07e-09 fT/√Hz (1 μm² SQUIDの場合)

6. 超伝導ナノワイヤ単一光子検出器（SNSPD）

6.1 SNSPDの動作原理

SNSPDは、バイアス電流下にある超薄膜超伝導ナノワイヤで構成されます。 単一光子の吸収により、以下のプロセスが進行します：

1. 光子がナノワイヤ内で吸収される
2. 高温の準粒子ホットスポットが形成される
3. ホットスポット内で超伝導が局所的に破壊される
4. 電流が常伝導領域に再分配される
5. 電流密度が増加し、より大きな常伝導領域が形成される
6. 抵抗パルスが発生し、読み出し回路で検出される
7. ホットスポットが冷却され、超伝導が回復する

6.2 主要な性能指標

6.3 SNSPDの応用

• 量子通信：量子鍵配送（QKD）
• 量子情報：光子量子ビットの測定
• 天文学：光子計数イメージング
• LiDAR：時間分解測距
• 蛍光寿命イメージング：生物医学研究
• 量子コンピューティング：光子ベースの量子計算

7. 超伝導エレクトロニクス

7.1 RSFQ論理（Rapid Single Flux Quantum）

RSFQ論理は、情報を磁束量子$\Phi_0$の単一パルスとして符号化する 超高速・低電力のデジタル論理ファミリーです。

基本原理：

• 論理 "1"：磁束量子パルスの存在
• 論理 "0"：パルスの不在
• パルス幅：~1 ps
• パルス電圧：~mV

主な利点：

• 超高速動作（>100 GHz）
• 極めて低い電力消費（~μW/ゲート）
• 自然なパイプライン化
• 低遅延

7.2 基本的なRSFQゲート

7.3 応用分野

• 高性能コンピューティング：超高速プロセッサ
• データセンター：エネルギー効率の高い計算
• 通信：高速ルーター・スイッチ
• 信号処理：ADC、DSP
• 量子コンピューティング：古典制御エレクトロニクス

8. 量子誤り訂正の基礎

8.1 なぜ量子誤り訂正が必要か

量子ビットのデコヒーレンスとゲートエラーは、フォールトトレラントな量子計算を実現するために 量子誤り訂正（QEC）を必要とします。

課題：

• 量子状態のクローン不可能性（複製不可定理）
• 測定による状態の破壊
• 連続的なエラー振幅

8.2 表面符号（Surface Code）

表面符号は、2次元格子上の物理量子ビットを使用する最も有望なQEC方式の一つです。

主要な特徴：

• 2次元局所接続（ハードウェア実装に適している）
• 高い閾値エラー率（~1%）
• 効率的なデコーディングアルゴリズム

距離$d$の表面符号：

• 物理量子ビット数：$\sim 2d^2$
• 論理量子ビット数：1
• 訂正可能なエラー数：$\lfloor (d-1)/2 \rfloor$

8.3 量子誤り訂正の閾値定理

物理エラー率$p$が閾値$p_{\text{th}}$未満であれば、 十分なリソース（物理量子ビット）を使用することで、 論理エラー率を任意に小さくできます：

表面符号の場合、$p_{\text{th}} \approx 1\%$です。

import numpy as np
import matplotlib.pyplot as plt

def logical_error_rate(p_phys, p_th, d):
    """
    表面符号の論理エラー率

    Parameters:
    -----------
    p_phys : float or array
        物理エラー率
    p_th : float
        閾値エラー率
    d : int
        符号距離

    Returns:
    --------
    p_log : float or array
        論理エラー率
    """
    return (p_phys / p_th) ** ((d + 1) / 2)

def required_qubits(d):
    """符号距離dに必要な物理量子ビット数（表面符号）"""
    return 2 * d**2

# パラメータ
p_th = 0.01  # 表面符号の閾値（1%）
distances = [3, 5, 7, 9, 11, 13]
p_phys_range = np.logspace(-4, -1.5, 100)

# プロット
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# 論理エラー率 vs 物理エラー率
for d in distances:
    p_log = logical_error_rate(p_phys_range, p_th, d)
    n_qubits = required_qubits(d)
    ax1.loglog(p_phys_range, p_log, linewidth=2,
               label=f'd={d} ({n_qubits} qubits)')

# 閾値を示す
ax1.axvline(x=p_th, color='red', linestyle='--', linewidth=2,
            label=f'閾値 p_th={p_th}')
ax1.axline((p_th, p_th), (1e-3, 1e-3), color='k', linestyle=':',
           linewidth=1.5, alpha=0.5)
ax1.set_xlabel('物理エラー率 $p_{phys}$', fontsize=12)
ax1.set_ylabel('論理エラー率 $p_{log}$', fontsize=12)
ax1.set_title('表面符号：論理 vs 物理エラー率', fontsize=13)
ax1.legend(fontsize=9, loc='upper left')
ax1.grid(True, alpha=0.3, which='both')
ax1.set_xlim([1e-4, 5e-2])
ax1.set_ylim([1e-12, 1])

# 目標論理エラー率に必要な符号距離
target_errors = [1e-3, 1e-6, 1e-9, 1e-12, 1e-15]
p_phys_values = [1e-4, 5e-4, 1e-3, 2e-3, 5e-3, 8e-3]

for p_phys in p_phys_values:
    d_values = np.arange(3, 50, 2)
    p_log_values = [logical_error_rate(p_phys, p_th, d) for d in d_values]
    ax2.semilogy(d_values, p_log_values, 'o-', linewidth=2,
                 markersize=4, label=f'$p_{{phys}}$={p_phys}')

for p_target in target_errors:
    ax2.axhline(y=p_target, color='gray', linestyle='--',
                alpha=0.3, linewidth=1)
    ax2.text(48, p_target, f'{p_target:.0e}', fontsize=8,
             va='center', ha='left')

ax2.set_xlabel('符号距離 $d$', fontsize=12)
ax2.set_ylabel('論理エラー率 $p_{log}$', fontsize=12)
ax2.set_title('必要な符号距離（目標論理エラー率）', fontsize=13)
ax2.legend(fontsize=9, loc='upper right')
ax2.grid(True, alpha=0.3, which='both')
ax2.set_xlim([3, 50])
ax2.set_ylim([1e-20, 1])

plt.tight_layout()
plt.savefig('surface_code_threshold.png', dpi=300, bbox_inches='tight')
plt.show()

# 具体的な例：10⁻¹²の論理エラー率を達成
print("=== 表面符号リソース推定 ===\n")
p_phys_target = 1e-3  # 0.1% 物理エラー率
p_log_target = 1e-12  # 目標論理エラー率

# 必要な距離を計算
d_required = int(np.ceil(2 * np.log(p_log_target) / np.log(p_phys_target/p_th) - 1))
if d_required % 2 == 0:  # 奇数にする
    d_required += 1

n_qubits = required_qubits(d_required)
p_log_achieved = logical_error_rate(p_phys_target, p_th, d_required)

print(f"目標：論理エラー率 < {p_log_target}")
print(f"物理エラー率：{p_phys_target} ({p_phys_target*100}%)")
print(f"閾値：{p_th} ({p_th*100}%)")
print(f"\n必要なパラメータ:")
print(f"  符号距離 d = {d_required}")
print(f"  物理量子ビット数 = {n_qubits}")
print(f"  達成論理エラー率 ≈ {p_log_achieved:.2e}")
print(f"\n1000論理量子ビットのフォールトトレラント量子コンピュータ:")
print(f"  総物理量子ビット数 ≈ {1000 * n_qubits:,}")
print(f"  (実際にはさらに補助量子ビットが必要)")

=== 表面符号リソース推定 ===

目標：論理エラー率 < 1e-12
物理エラー率：0.001 (0.1%)
閾値：0.01 (1.0%)

必要なパラメータ:
  符号距離 d = 13
  物理量子ビット数 = 338
  達成論理エラー率 ≈ 2.05e-13

1000論理量子ビットのフォールトトレラント量子コンピュータ:
  総物理量子ビット数 ≈ 338,000
  (実際にはさらに補助量子ビットが必要)

9. 量子コンピューティングハードウェアの現状

9.1 主要なプラットフォーム

9.2 現在のベンチマーク

9.3 フォールトトレラント量子計算への道筋

9.4 主要な課題と研究方向

1. コヒーレンス時間の向上：材料科学、設計最適化
2. スケーラビリティ：大規模集積、配線、制御
3. エラー率の低減：QEC閾値以下への到達
4. 読み出し忠実度：高速・高忠実度測定
5. 量子ビット接続性：全対全結合の実現
6. 極低温エレクトロニクス：量子ビット近傍での制御
7. アルゴリズム開発：NISQおよびフォールトトレラント時代向け

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle

# 主要プラットフォームのデータ
platforms = {
    'IBM Quantum': {
        'qubits': 433,
        'T1': 100,
        'single_gate_fidelity': 99.97,
        'two_gate_fidelity': 99.3,
        'readout_fidelity': 99.5,
        'year': 2022
    },
    'Google Sycamore': {
        'qubits': 70,
        'T1': 30,
        'single_gate_fidelity': 99.96,
        'two_gate_fidelity': 99.5,
        'readout_fidelity': 99.7,
        'year': 2019
    },
    'Rigetti Aspen-M': {
        'qubits': 80,
        'T1': 20,
        'single_gate_fidelity': 99.5,
        'two_gate_fidelity': 98.5,
        'readout_fidelity': 99.0,
        'year': 2021
    },
    'IQM': {
        'qubits': 20,
        'T1': 50,
        'single_gate_fidelity': 99.9,
        'two_gate_fidelity': 99.0,
        'readout_fidelity': 99.3,
        'year': 2023
    },
    'Fluxonium (研究)': {
        'qubits': 2,
        'T1': 1000,
        'single_gate_fidelity': 99.98,
        'two_gate_fidelity': 99.4,
        'readout_fidelity': 99.8,
        'year': 2023
    }
}

# プロット
fig = plt.figure(figsize=(16, 10))

# 1. 量子ビット数 vs T1時間
ax1 = plt.subplot(2, 2, 1)
for name, data in platforms.items():
    ax1.scatter(data['qubits'], data['T1'], s=150, alpha=0.7, label=name)
    ax1.annotate(name, (data['qubits'], data['T1']),
                xytext=(10, 5), textcoords='offset points', fontsize=9)

ax1.set_xlabel('量子ビット数', fontsize=12)
ax1.set_ylabel(r'T₁ コヒーレンス時間 (μs)', fontsize=12)
ax1.set_title('量子ビット数 vs コヒーレンス時間', fontsize=13)
ax1.set_xscale('log')
ax1.set_yscale('log')
ax1.grid(True, alpha=0.3, which='both')

# 2. ゲート忠実度の比較
ax2 = plt.subplot(2, 2, 2)
names = list(platforms.keys())
single_fidelity = [platforms[n]['single_gate_fidelity'] for n in names]
two_fidelity = [platforms[n]['two_gate_fidelity'] for n in names]
readout_fidelity = [platforms[n]['readout_fidelity'] for n in names]

x = np.arange(len(names))
width = 0.25

ax2.bar(x - width, single_fidelity, width, label='単一量子ビットゲート', alpha=0.8)
ax2.bar(x, two_fidelity, width, label='2量子ビットゲート', alpha=0.8)
ax2.bar(x + width, readout_fidelity, width, label='読み出し', alpha=0.8)

ax2.set_ylabel('忠実度 (%)', fontsize=12)
ax2.set_title('ゲート忠実度の比較', fontsize=13)
ax2.set_xticks(x)
ax2.set_xticklabels(names, rotation=45, ha='right', fontsize=9)
ax2.legend(fontsize=10)
ax2.grid(True, alpha=0.3, axis='y')
ax2.set_ylim([97, 100.5])

# 3. 総合性能スコア（レーダーチャート風）
ax3 = plt.subplot(2, 2, 3)

# 正規化スコア計算関数
def normalize_score(value, min_val, max_val):
    return (value - min_val) / (max_val - min_val) * 100

colors = plt.cm.Set3(np.linspace(0, 1, len(platforms)))

for i, (name, data) in enumerate(platforms.items()):
    # 各指標を0-100にスケール
    scale_score = normalize_score(np.log10(data['qubits']),
                                   np.log10(2), np.log10(500))
    coherence_score = normalize_score(np.log10(data['T1']),
                                       np.log10(10), np.log10(1000))
    gate_score = (data['single_gate_fidelity'] + data['two_gate_fidelity']) / 2 - 98

    total_score = (scale_score + coherence_score + gate_score) / 3

    ax3.barh(i, total_score, color=colors[i], alpha=0.7, edgecolor='black')

ax3.set_yticks(range(len(platforms)))
ax3.set_yticklabels(names, fontsize=10)
ax3.set_xlabel('総合性能スコア', fontsize=12)
ax3.set_title('プラットフォーム総合評価', fontsize=13)
ax3.grid(True, alpha=0.3, axis='x')

# 4. 時系列発展
ax4 = plt.subplot(2, 2, 4)

years = sorted(set(data['year'] for data in platforms.values()))
max_qubits_by_year = {}
max_T1_by_year = {}

for year in years:
    platforms_in_year = [d for d in platforms.values() if d['year'] == year]
    max_qubits_by_year[year] = max(p['qubits'] for p in platforms_in_year)
    max_T1_by_year[year] = max(p['T1'] for p in platforms_in_year)

ax4_twin = ax4.twinx()

ax4.plot(list(max_qubits_by_year.keys()),
         list(max_qubits_by_year.values()),
         'bo-', linewidth=2, markersize=8, label='最大量子ビット数')
ax4_twin.plot(list(max_T1_by_year.keys()),
              list(max_T1_by_year.values()),
              'rs-', linewidth=2, markersize=8, label='最大T₁時間')

ax4.set_xlabel('年', fontsize=12)
ax4.set_ylabel('量子ビット数', fontsize=12, color='b')
ax4_twin.set_ylabel(r'T₁ (μs)', fontsize=12, color='r')
ax4.set_title('量子コンピューティングの進歩', fontsize=13)
ax4.tick_params(axis='y', labelcolor='b')
ax4_twin.tick_params(axis='y', labelcolor='r')
ax4.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('quantum_platform_comparison.png', dpi=300, bbox_inches='tight')
plt.show()

# 統計サマリー
print("=== 量子コンピューティングプラットフォーム統計 ===\n")
for name, data in platforms.items():
    print(f"{name}:")
    print(f"  量子ビット数: {data['qubits']}")
    print(f"  T₁時間: {data['T1']} μs")
    print(f"  単一量子ビットゲート忠実度: {data['single_gate_fidelity']}%")
    print(f"  2量子ビットゲート忠実度: {data['two_gate_fidelity']}%")
    print(f"  読み出し忠実度: {data['readout_fidelity']}%")
    print(f"  年: {data['year']}\n")

# エラー訂正に必要な改善
print("=== QEC閾値に向けた進捗 ===")
p_th = 0.01  # 表面符号閾値
current_best_error = (100 - 99.5) / 100  # 現在の最良2量子ビットゲートエラー率
print(f"表面符号閾値: {p_th*100}% エラー率")
print(f"現在の最良ゲートエラー率: {current_best_error*100}%")
print(f"閾値までの改善率: {current_best_error/p_th:.2f}x")
print(f"状態: {'閾値以下達成！' if current_best_error < p_th else '閾値にほぼ到達'}")

=== 量子コンピューティングプラットフォーム統計 ===

IBM Quantum:
  量子ビット数: 433
  T₁時間: 100 μs
  単一量子ビットゲート忠実度: 99.97%
  2量子ビットゲート忠実度: 99.3%
  読み出し忠実度: 99.5%
  年: 2022

Google Sycamore:
  量子ビット数: 70
  T₁時間: 30 μs
  単一量子ビットゲート忠実度: 99.96%
  2量子ビットゲート忠実度: 99.5%
  読み出し忠実度: 99.7%
  年: 2019

=== QEC閾値に向けた進捗 ===
表面符号閾値: 1.0% エラー率
現在の最良ゲートエラー率: 0.5%
閾値までの改善率: 0.50x
状態: 閾値以下達成！

まとめ

本章では、超伝導量子デバイスの広範な応用について学びました。 超伝導量子ビットは、量子コンピューティング革命の最前線にあり、 transmonやfluxoniumなどの設計により、急速にコヒーレンス時間と ゲート忠実度が向上しています。

回路量子電磁力学（cQED）は、量子ビット制御と測定の基盤を提供し、 dispersive regimeでの量子非破壊測定を可能にします。 デコヒーレンスとの戦いは継続していますが、材料改善、設計最適化、 そして最終的には量子誤り訂正により、フォールトトレラントな 量子計算の実現が視野に入ってきました。

SQUIDとSNSPDは、精密測定と単一光子検出における超伝導の威力を示しており、 生物医学研究から量子通信まで、幅広い分野に革命をもたらしています。 RSFQ論理は、超高速・低電力の古典計算を約束し、 将来の量子-古典ハイブリッドシステムにおいて重要な役割を果たすでしょう。

量子誤り訂正、特に表面符号は、現在のNISQ（Noisy Intermediate-Scale Quantum） 時代から、フォールトトレラントな量子計算への橋渡しとなります。 現在の超伝導量子ビットは、QEC閾値に到達しつつあり、 今後数年間で、初期のエラー訂正実装が期待されます。

演習問題