from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
 
# 量子回路の作成（2量子ビットのベル状態）
qc = QuantumCircuit(2, 2)
 
# アダマールゲート: |0⟩ → (|0⟩ + |1⟩) / √2  (重ね合わせ)
qc.h(0)
 
# CNOTゲート: 量子もつれの生成
qc.cx(0, 1)
 
# 測定
qc.measure([0, 1], [0, 1])
 
print(qc.draw())
#      ┌───┐     ┌─┐
# q_0: ┤ H ├──■──┤M├───
#      └───┘┌─┴─┐└╥┘┌─┐
# q_1: ────┤ X ├─╫─┤M├
#           └───┘ ║ └╥┘
# c: 2/══════════╩══╩═
#                 0  1
 
# シミュレーション実行
simulator = AerSimulator()
compiled = transpile(qc, simulator)
result = simulator.run(compiled, shots=1000).result()
counts = result.get_counts()
print(counts)  # {'00': 498, '11': 502}
# → |00⟩ と |11⟩ がほぼ等確率（量子もつれ）

from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
from qiskit_machine_learning.algorithms import VQC
from qiskit_algorithms.optimizers import COBYLA
 
# 量子変分分類器
feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
ansatz = RealAmplitudes(num_qubits=2, reps=2)
 
vqc = VQC(
    feature_map=feature_map,
    ansatz=ansatz,
    optimizer=COBYLA(maxiter=100),
    quantum_instance=AerSimulator(),
)
 
# 学習
vqc.fit(X_train, y_train)
 
# 予測
predictions = vqc.predict(X_test)
accuracy = np.mean(predictions == y_test)
print(f"量子分類器の精度: {accuracy:.2%}")

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
import numpy as np
 
def grover_search(n_qubits: int, target_state: str) -> dict:
    """
    Groverの探索アルゴリズムの実装
    N個の要素から目的の要素を O(√N) で見つける
    古典アルゴリズムの O(N) に対して二次高速化
 
    Parameters
    ----------
    n_qubits : int
        量子ビット数（探索空間 = 2^n_qubits）
    target_state : str
        探索対象の状態（例: '101'）
 
    Returns
    -------
    dict
        測定結果の頻度辞書
    """
    qc = QuantumCircuit(n_qubits, n_qubits)
 
    # Step 1: 均等な重ね合わせ状態を作成
    qc.h(range(n_qubits))
 
    # 最適な反復回数: π/4 * √(2^n)
    num_iterations = int(np.pi / 4 * np.sqrt(2 ** n_qubits))
 
    for _ in range(num_iterations):
        # Step 2: オラクル — 目的の状態の位相を反転
        # target_state の '0' に対応するビットにXゲートを適用
        for i, bit in enumerate(reversed(target_state)):
            if bit == '0':
                qc.x(i)
 
        # 多制御Zゲート（位相反転）
        qc.h(n_qubits - 1)
        qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
        qc.h(n_qubits - 1)
 
        # Xゲートを元に戻す
        for i, bit in enumerate(reversed(target_state)):
            if bit == '0':
                qc.x(i)
 
        # Step 3: 拡散演算子（振幅増幅）
        qc.h(range(n_qubits))
        qc.x(range(n_qubits))
 
        qc.h(n_qubits - 1)
        qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
        qc.h(n_qubits - 1)
 
        qc.x(range(n_qubits))
        qc.h(range(n_qubits))
 
    # 測定
    qc.measure(range(n_qubits), range(n_qubits))
 
    # シミュレーション
    simulator = AerSimulator()
    result = simulator.run(qc, shots=1024).result()
    counts = result.get_counts()
 
    # 結果表示
    print(f"探索空間: 2^{n_qubits} = {2**n_qubits} 要素")
    print(f"探索対象: |{target_state}⟩")
    print(f"反復回数: {num_iterations}")
    print(f"結果: {counts}")
    # ターゲット状態が高確率で観測される
    return counts
 
# 使用例: 8要素(3量子ビット)から '101' を探索
result = grover_search(3, '101')
# 出力例:
# 探索空間: 2^3 = 8 要素
# 探索対象: |101⟩
# 反復回数: 2
# 結果: {'101': 945, '000': 11, '010': 13, ...}
# → 101 が 約92% の確率で検出される

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
 
def quantum_teleportation():
    """
    量子テレポーテーションプロトコル
    量子状態を物理的に移動せず、古典通信と量子もつれを使って転送する
 
    Alice が量子ビット |ψ⟩ = α|0⟩ + β|1⟩ を Bob に送信する
    """
    # 3量子ビット: q0(送信状態), q1(Alice), q2(Bob)
    # 2古典ビット: Aliceの測定結果
    qc = QuantumCircuit(3, 2)
 
    # 送信したい状態を準備（例: |ψ⟩ に適当な回転を適用）
    qc.rx(1.2, 0)   # α, β を決定する回転
    qc.rz(0.7, 0)
 
    qc.barrier()
 
    # Step 1: Alice と Bob の間にベル状態（量子もつれ）を生成
    qc.h(1)        # アダマールゲート
    qc.cx(1, 2)    # CNOT → |Φ+⟩ = (|00⟩ + |11⟩)/√2
 
    qc.barrier()
 
    # Step 2: Alice が Bell 測定を実行
    qc.cx(0, 1)    # CNOT
    qc.h(0)        # アダマール
    qc.measure(0, 0)  # q0 を測定 → c0
    qc.measure(1, 1)  # q1 を測定 → c1
 
    qc.barrier()
 
    # Step 3: Bob が測定結果に基づいて補正
    qc.x(2).c_if(1, 1)   # c1=1 なら X ゲート
    qc.z(2).c_if(0, 1)   # c0=1 なら Z ゲート
 
    # Bob の q2 が元の |ψ⟩ と同じ状態になる
 
    print(qc.draw())
    return qc
 
# 実行
qc = quantum_teleportation()
 
# 重要なポイント:
# - 量子状態は複製できない（量子ノークローニング定理）
# - テレポーテーション後、元の状態は破壊される
# - 古典通信チャネルが必要（超光速通信ではない）
# - 量子インターネットの基盤技術

"""
ポスト量子暗号の概要と移行計画
 
NIST が 2024年に標準化したポスト量子暗号アルゴリズム:
- ML-KEM (旧CRYSTALS-Kyber): 鍵カプセル化メカニズム
- ML-DSA (旧CRYSTALS-Dilithium): デジタル署名
- SLH-DSA (旧SPHINCS+): ハッシュベースの署名
 
企業が今すぐ始めるべき移行ステップ:
"""
 
# 移行チェックリスト
pqc_migration_checklist = {
    "Phase 1: 暗号インベントリ (2024-2025)": [
        "使用中の暗号アルゴリズムの棚卸し",
        "RSA/ECDSAの使用箇所を特定",
        "TLS証明書の暗号方式を確認",
        "暗号アジリティ（切り替え容易性）の評価",
    ],
    "Phase 2: ハイブリッド移行 (2025-2028)": [
        "TLS 1.3 + ML-KEM ハイブリッドモードの導入",
        "署名の ML-DSA ハイブリッド化",
        "テスト環境でのパフォーマンス検証",
        "鍵サイズ増大によるネットワーク影響の評価",
    ],
    "Phase 3: 完全移行 (2028-2035)": [
        "従来暗号アルゴリズムの段階的廃止",
        "全システムのPQC対応完了",
        "長期保存データの再暗号化",
        "サプライチェーン全体のPQC対応確認",
    ],
}
 
# PQC アルゴリズムの比較
pqc_comparison = {
    "ML-KEM-768": {
        "用途": "鍵交換",
        "公開鍵サイズ": "1184 bytes",
        "暗号文サイズ": "1088 bytes",
        "セキュリティレベル": "NIST Level 3",
        "性能": "RSAより高速",
    },
    "ML-DSA-65": {
        "用途": "デジタル署名",
        "公開鍵サイズ": "1952 bytes",
        "署名サイズ": "3293 bytes",
        "セキュリティレベル": "NIST Level 3",
        "性能": "RSA署名より高速、検証はやや遅い",
    },
    "SLH-DSA-SHA2-128s": {
        "用途": "デジタル署名（ステートレス）",
        "公開鍵サイズ": "32 bytes",
        "署名サイズ": "7856 bytes",
        "セキュリティレベル": "NIST Level 1",
        "性能": "署名が遅いが、理論的安全性が高い",
    },
}
 
for algo, specs in pqc_comparison.items():
    print(f"\n{algo}:")
    for key, value in specs.items():
        print(f"  {key}: {value}")

import snntorch as snn
import torch
import torch.nn as nn
 
class SpikingNet(nn.Module):
    """
    スパイキングニューラルネットワーク
    従来のANNと異なり、ニューロンは「発火」するかしないかの2値
    時間方向の情報を自然に処理できる
    """
    def __init__(self, num_inputs=784, num_hidden=256, num_outputs=10,
                 beta=0.95, num_steps=25):
        super().__init__()
        self.num_steps = num_steps
 
        # 全結合層
        self.fc1 = nn.Linear(num_inputs, num_hidden)
        self.fc2 = nn.Linear(num_hidden, num_outputs)
 
        # Leaky Integrate-and-Fire (LIF) ニューロン
        self.lif1 = snn.Leaky(beta=beta)  # beta: 膜電位の減衰率
        self.lif2 = snn.Leaky(beta=beta)
 
    def forward(self, x):
        # 膜電位の初期化
        mem1 = self.lif1.init_leaky()
        mem2 = self.lif2.init_leaky()
 
        spk2_rec = []  # 出力スパイクの記録
        mem2_rec = []  # 膜電位の記録
 
        # 時間ステップごとに処理
        for step in range(self.num_steps):
            cur1 = self.fc1(x)
            spk1, mem1 = self.lif1(cur1, mem1)
 
            cur2 = self.fc2(spk1)
            spk2, mem2 = self.lif2(cur2, mem2)
 
            spk2_rec.append(spk2)
            mem2_rec.append(mem2)
 
        # スパイク発火率で分類
        return torch.stack(spk2_rec), torch.stack(mem2_rec)
 
# 学習ループ
net = SpikingNet()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)
loss_fn = snn.functional.ce_rate_loss()  # スパイク率ベースの損失
 
for epoch in range(10):
    for data, targets in train_loader:
        spk_rec, mem_rec = net(data)
        loss = loss_fn(spk_rec, targets)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

import torch
import torch.nn as nn
import snntorch as snn
from snntorch import spikegen
 
class EventDrivenVisionNet(nn.Module):
    """
    イベントカメラ（DVS: Dynamic Vision Sensor）データを
    SNNで処理するネットワーク
 
    イベントカメラの特徴:
    - フレームベースではなく、画素単位で輝度変化を検出
    - マイクロ秒の時間分解能
    - 高ダイナミックレンジ（120dB+）
    - 低消費電力、低データレート
    - 自動運転、ロボティクスで注目
 
    SNNとの相性が極めて良い:
    - どちらもイベント駆動
    - スパースなデータを効率的に処理
    """
    def __init__(self, input_channels=2, num_classes=10,
                 beta=0.9, num_steps=50):
        super().__init__()
        self.num_steps = num_steps
 
        # 畳み込み層（時空間特徴抽出）
        self.conv1 = nn.Conv2d(input_channels, 32, 3, padding=1)
        self.pool1 = nn.AvgPool2d(2)
        self.lif1 = snn.Leaky(beta=beta)
 
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool2 = nn.AvgPool2d(2)
        self.lif2 = snn.Leaky(beta=beta)
 
        self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
        self.pool3 = nn.AvgPool2d(2)
        self.lif3 = snn.Leaky(beta=beta)
 
        # 全結合分類層
        self.fc1 = nn.Linear(128 * 4 * 4, 256)
        self.lif4 = snn.Leaky(beta=beta)
 
        self.fc2 = nn.Linear(256, num_classes)
        self.lif5 = snn.Leaky(beta=beta)
 
    def forward(self, event_stream):
        """
        Parameters
        ----------
        event_stream : torch.Tensor
            形状 [batch, time_steps, channels, height, width]
            channels: ON/OFFイベントの2チャンネル
        """
        mem1 = self.lif1.init_leaky()
        mem2 = self.lif2.init_leaky()
        mem3 = self.lif3.init_leaky()
        mem4 = self.lif4.init_leaky()
        mem5 = self.lif5.init_leaky()
 
        spk_out_rec = []
 
        for t in range(self.num_steps):
            x = event_stream[:, t]  # 時刻 t のイベントフレーム
 
            # 畳み込み + スパイキング
            x = self.pool1(self.conv1(x))
            spk1, mem1 = self.lif1(x, mem1)
 
            x = self.pool2(self.conv2(spk1))
            spk2, mem2 = self.lif2(x, mem2)
 
            x = self.pool3(self.conv3(spk2))
            spk3, mem3 = self.lif3(x, mem3)
 
            # Flatten
            x = spk3.view(spk3.size(0), -1)
 
            x = self.fc1(x)
            spk4, mem4 = self.lif4(x, mem4)
 
            x = self.fc2(spk4)
            spk5, mem5 = self.lif5(x, mem5)
 
            spk_out_rec.append(spk5)
 
        return torch.stack(spk_out_rec)
 
# エネルギー効率の比較（推論1回あたり）
energy_comparison = {
    "GPU (NVIDIA A100)": {
        "消費電力": "300W",
        "推論レイテンシ": "1ms",
        "エネルギー/推論": "300mJ",
        "スループット": "数千FPS",
    },
    "Loihi 2": {
        "消費電力": "1W",
        "推論レイテンシ": "5ms",
        "エネルギー/推論": "5mJ",
        "スループット": "200FPS",
    },
    "Akida (BrainChip)": {
        "消費電力": "数mW",
        "推論レイテンシ": "1ms",
        "エネルギー/推論": "数μJ",
        "スループット": "30FPS",
    },
}
# Loihi 2 は GPU の 60分の1 のエネルギーで推論可能
# Akida はさらに1000分の1以下

"""
Intel Lava フレームワークによるニューロモルフィック計算
Loihi 2 チップ上で直接実行可能
 
Lava はハードウェア抽象化レイヤーを提供し、
CPU/GPU シミュレーションと Loihi 実機を切り替え可能
"""
from lava.proc.lif.process import LIF
from lava.proc.dense.process import Dense
from lava.proc.io.source import RingBuffer as Source
from lava.proc.io.sink import RingBuffer as Sink
from lava.magma.core.run_configs import Loihi2SimCfg
from lava.magma.core.run_conditions import RunSteps
import numpy as np
 
# ネットワーク構成
num_inputs = 64
num_hidden = 128
num_outputs = 10
num_steps = 100
 
# 入力データ（スパイク列として表現）
input_spikes = np.random.binomial(1, 0.1, (num_inputs, num_steps))
 
# プロセス（ノード）の定義
source = Source(data=input_spikes)
 
# Dense（全結合シナプス）
weights_1 = np.random.randn(num_hidden, num_inputs) * 0.1
dense_1 = Dense(weights=weights_1)
 
# LIF ニューロン
lif_1 = LIF(
    shape=(num_hidden,),
    vth=1.0,        # 発火閾値
    du=0.9,         # 電流減衰率
    dv=0.8,         # 電圧減衰率
    bias_mant=0,    # バイアス
)
 
weights_2 = np.random.randn(num_outputs, num_hidden) * 0.1
dense_2 = Dense(weights=weights_2)
 
lif_2 = LIF(
    shape=(num_outputs,),
    vth=1.0,
    du=0.9,
    dv=0.8,
)
 
sink = Sink(shape=(num_outputs,), buffer=num_steps)
 
# プロセス間の接続（データフローグラフ）
source.s_out.connect(dense_1.s_in)
dense_1.a_out.connect(lif_1.a_in)
lif_1.s_out.connect(dense_2.s_in)
dense_2.a_out.connect(lif_2.a_in)
lif_2.s_out.connect(sink.a_in)
 
# 実行（シミュレーションモード）
run_cfg = Loihi2SimCfg()
lif_2.run(condition=RunSteps(num_steps=num_steps), run_cfg=run_cfg)
 
# 出力スパイクの取得
output_spikes = sink.data.get()
print(f"出力スパイク形状: {output_spikes.shape}")  # (10, 100)
print(f"各ニューロンの発火率: {output_spikes.mean(axis=1)}")
 
# 停止
lif_2.stop()
 
# Loihi 2 実機で実行する場合:
# run_cfg = Loihi2HwCfg()  # ハードウェア構成に切り替えるだけ
# コードの変更は不要 → ハードウェア抽象化の利点

import numpy as np
 
class PhotonicNeuralNetwork:
    """
    光ニューラルネットワークのシミュレーション
    マッハ・ツェンダー干渉計（MZI）メッシュで行列演算を実装
    """
    def __init__(self, input_dim, output_dim):
        self.input_dim = input_dim
        self.output_dim = output_dim
 
        # MZI の位相パラメータ（学習対象）
        self.theta = np.random.uniform(0, 2*np.pi, (input_dim, output_dim))
        self.phi = np.random.uniform(0, 2*np.pi, (input_dim, output_dim))
 
    def mzi_transfer(self, theta, phi):
        """マッハ・ツェンダー干渉計の伝達行列"""
        return np.array([
            [np.exp(1j*phi) * np.cos(theta/2), -np.sin(theta/2)],
            [np.exp(1j*phi) * np.sin(theta/2),  np.cos(theta/2)]
        ])
 
    def forward(self, x):
        """
        光の干渉を使った行列演算
        電子回路: O(n^2) の乗算
        光回路: O(1) — 光速で瞬時に計算
        """
        # 入力を光の振幅としてエンコード
        optical_input = np.sqrt(np.abs(x)) * np.exp(1j * np.angle(x + 0j))
 
        # MZIメッシュを通過（行列演算に相当）
        output = np.zeros(self.output_dim, dtype=complex)
        for j in range(self.output_dim):
            for i in range(self.input_dim):
                phase_shift = np.exp(1j * self.theta[i, j])
                output[j] += optical_input[i] * phase_shift
 
        # 光検出器で強度を測定（複素数→実数）
        detected = np.abs(output) ** 2
 
        # 非線形活性化（電気-光変換で実現）
        return self._electro_optic_nonlinearity(detected)
 
    def _electro_optic_nonlinearity(self, x):
        """電気光学変調器による非線形変換"""
        return np.tanh(x)
 
# 理論的な速度比較
# 128x128 行列乗算:
#   GPU (A100):     ~1 TFLOPS → ~16μs
#   光プロセッサ:    光速 → ~0.01μs (1000倍高速)
#   消費電力:        GPU ~400W vs 光 ~10W

import numpy as np
from scipy.signal import fftconvolve
 
class PhotonicReservoir:
    """
    光リザバーコンピューティング
    ランダムな光学系（リザバー）を使って時系列データを処理する
 
    原理:
    - 光の干渉と非線形応答がランダムな高次元写像を生成
    - リザバー自体は学習不要（ランダム固定）
    - 出力層の線形回帰のみ学習
    - 超高速（光速処理）+ 低消費電力
    """
    def __init__(self, input_dim, reservoir_dim, spectral_radius=0.95):
        self.input_dim = input_dim
        self.reservoir_dim = reservoir_dim
 
        # 入力結合行列（ランダム固定）
        self.W_in = np.random.randn(reservoir_dim, input_dim) * 0.1
 
        # リザバー内部結合（光学的にはMZIメッシュのランダム構成）
        W = np.random.randn(reservoir_dim, reservoir_dim)
        # スペクトル半径の調整（安定性のため）
        eigenvalues = np.linalg.eigvals(W)
        W = W * spectral_radius / np.max(np.abs(eigenvalues))
        self.W_res = W
 
        # 出力重み（学習対象）
        self.W_out = None
 
        # リザバー状態
        self.state = np.zeros(reservoir_dim)
 
    def _optical_nonlinearity(self, x):
        """
        光学的非線形性のモデル
        実際のシステムでは半導体光増幅器（SOA）や
        Kerr効果による自己位相変調で実現
        """
        return np.sin(x) ** 2  # 光検出器の2乗応答 + 干渉
 
    def forward(self, u):
        """リザバーの状態更新（1ステップ）"""
        # 光の伝搬をシミュレート
        self.state = self._optical_nonlinearity(
            self.W_res @ self.state + self.W_in @ u
        )
        return self.state
 
    def fit(self, input_sequence, target_sequence, reg=1e-6):
        """
        出力層の学習（リッジ回帰）
        リザバー内部は学習不要 → 学習が極めて高速
        """
        n_samples = len(input_sequence)
        states = np.zeros((n_samples, self.reservoir_dim))
 
        # リザバーの駆動
        self.state = np.zeros(self.reservoir_dim)
        for t in range(n_samples):
            states[t] = self.forward(input_sequence[t])
 
        # リッジ回帰で出力重みを求める
        R = states.T @ states + reg * np.eye(self.reservoir_dim)
        P = states.T @ target_sequence
        self.W_out = np.linalg.solve(R, P)
 
        return states @ self.W_out
 
    def predict(self, input_sequence):
        """予測"""
        n_samples = len(input_sequence)
        states = np.zeros((n_samples, self.reservoir_dim))
 
        for t in range(n_samples):
            states[t] = self.forward(input_sequence[t])
 
        return states @ self.W_out
 
# 使用例: カオス時系列（Mackey-Glass）の予測
def mackey_glass(n, tau=17, beta=0.2, gamma=0.1, n_init=0.9):
    """Mackey-Glass カオス時系列の生成"""
    x = np.zeros(n + tau)
    x[:tau] = n_init
    for t in range(tau, n + tau):
        x[t] = x[t-1] + beta * x[t-tau] / (1 + x[t-tau]**10) - gamma * x[t-1]
    return x[tau:]
 
# データ生成
data = mackey_glass(5000)
train_data = data[:4000].reshape(-1, 1)
test_data = data[4000:].reshape(-1, 1)
 
# リザバー構築
reservoir = PhotonicReservoir(input_dim=1, reservoir_dim=500)
 
# 1ステップ先予測の学習
train_pred = reservoir.fit(train_data[:-1], train_data[1:])
test_pred = reservoir.predict(test_data[:-1])
 
# 精度評価
mse = np.mean((test_pred - test_data[1:]) ** 2)
print(f"テスト MSE: {mse:.6f}")
# 光リザバーは時系列予測に優れた性能を発揮

from qiskit.primitives import Estimator
from qiskit.circuit.library import TwoLocal
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import SPSA
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper
 
# 水素分子 (H2) のエネルギー計算
driver = PySCFDriver(atom="H 0 0 0; H 0 0 0.735", basis="sto-3g")
problem = driver.run()
 
# 量子ビットへのマッピング
mapper = JordanWignerMapper()
qubit_op = mapper.map(problem.second_q_ops()[0])
 
# 変分回路（試行波動関数）
ansatz = TwoLocal(
    num_qubits=qubit_op.num_qubits,
    rotation_blocks=['ry', 'rz'],
    entanglement_blocks='cz',
    reps=2,
)
 
# VQE 実行
estimator = Estimator()
optimizer = SPSA(maxiter=200)
 
vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(qubit_op)
 
print(f"H2 基底状態エネルギー: {result.eigenvalue:.6f} Ha")
print(f"厳密解: -1.137275 Ha")
# 量子コンピュータで化学的に正確なエネルギーを計算

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit.quantum_info import SparsePauliOp
import numpy as np
 
def create_maxcut_hamiltonian(edges: list, num_nodes: int) -> SparsePauliOp:
    """
    MaxCut問題のハミルトニアンを構築
    MaxCut: グラフのノードを2グループに分割し、
            グループ間のエッジ数を最大化する NP困難問題
 
    物流、スケジューリング、VLSI設計などに応用
    """
    pauli_list = []
    coeffs = []
 
    for i, j in edges:
        # 各エッジに対して 0.5 * (I - Z_i * Z_j) の項
        # Z_i と Z_j が異なる場合（カットされたエッジ）にエネルギーが低くなる
        z_str = ['I'] * num_nodes
        z_str[i] = 'Z'
        z_str[j] = 'Z'
        pauli_list.append(''.join(z_str))
        coeffs.append(-0.5)
 
        # 定数項
        pauli_list.append('I' * num_nodes)
        coeffs.append(0.5)
 
    return SparsePauliOp(pauli_list, coeffs).simplify()
 
# MaxCut問題の定義（5ノードのグラフ）
edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0), (0, 2)]
num_nodes = 5
 
hamiltonian = create_maxcut_hamiltonian(edges, num_nodes)
 
# QAOA 実行
sampler = Sampler()
optimizer = COBYLA(maxiter=300)
 
qaoa = QAOA(
    sampler=sampler,
    optimizer=optimizer,
    reps=3,           # QAOAの層数（p値）
    initial_point=np.random.uniform(-np.pi, np.pi, 6),
)
 
result = qaoa.compute_minimum_eigenvalue(hamiltonian)
 
# 最適解の解析
best_bitstring = max(result.eigenstate, key=result.eigenstate.get)
print(f"最適なカット: {best_bitstring}")
print(f"カットされたエッジ数: {-result.eigenvalue:.0f}")
 
# 古典的な全探索との比較
# 5ノード: 2^5 = 32 通り → 古典で十分高速
# 100ノード: 2^100 通り → 古典では事実上不可能
# QAOAの利点: 近似解を多項式時間で求められる可能性

import pennylane as qml
from pennylane import numpy as np
 
# 量子デバイスの設定
n_qubits = 4
dev = qml.device("default.qubit", wires=n_qubits)
 
@qml.qnode(dev)
def quantum_neural_net(inputs, weights):
    """
    量子ニューラルネットワーク（QNN）
    パラメータ化量子回路を使った分類器
 
    古典 → 量子 → 古典 のハイブリッドアーキテクチャ
    """
    # データエンコーディング（角度エンコーディング）
    for i in range(n_qubits):
        qml.RX(inputs[i], wires=i)
 
    # 変分層（学習可能なパラメータ）
    for layer in range(len(weights)):
        # 回転ゲート
        for i in range(n_qubits):
            qml.RY(weights[layer][i][0], wires=i)
            qml.RZ(weights[layer][i][1], wires=i)
 
        # エンタングルメント層（環状接続）
        for i in range(n_qubits):
            qml.CNOT(wires=[i, (i + 1) % n_qubits])
 
    # 測定（期待値）
    return [qml.expval(qml.PauliZ(i)) for i in range(n_qubits)]
 
def hybrid_classifier(inputs, weights, classical_weights, bias):
    """
    ハイブリッド量子-古典分類器
    量子回路の出力を古典層で後処理
    """
    # 量子処理
    q_output = np.array(quantum_neural_net(inputs, weights))
 
    # 古典後処理（線形層 + シグモイド）
    logit = np.dot(classical_weights, q_output) + bias
    return 1 / (1 + np.exp(-logit))  # シグモイド
 
# パラメータの初期化
n_layers = 3
weights = np.random.randn(n_layers, n_qubits, 2, requires_grad=True) * 0.1
classical_weights = np.random.randn(n_qubits, requires_grad=True) * 0.1
bias = np.array(0.0, requires_grad=True)
 
# 学習ループ
optimizer = qml.GradientDescentOptimizer(stepsize=0.1)
 
for epoch in range(100):
    total_loss = 0
    for x, y in zip(X_train, y_train):
        # 損失関数（二値交差エントロピー）
        def cost(w, cw, b):
            pred = hybrid_classifier(x, w, cw, b)
            return -(y * np.log(pred + 1e-8) + (1-y) * np.log(1-pred + 1e-8))
 
        weights, classical_weights, bias = optimizer.step(
            cost, weights, classical_weights, bias
        )
        total_loss += cost(weights, classical_weights, bias)
 
    if epoch % 10 == 0:
        print(f"Epoch {epoch}: Loss = {total_loss / len(X_train):.4f}")
 
# PennyLane の利点:
# - 自動微分に対応（パラメータシフト則）
# - PyTorch, TensorFlow との統合
# - 実機 (IBM, IonQ, Rigetti) での実行が可能
# - ノイズモデルのシミュレーション

"""
現在利用可能な量子コンピュータクラウドサービス
 
エンジニアが実際に量子コンピュータを試す方法
"""
 
# 1. IBM Quantum (無料枠あり)
# pip install qiskit qiskit-ibm-runtime
from qiskit_ibm_runtime import QiskitRuntimeService
 
service = QiskitRuntimeService(channel="ibm_quantum")
# 利用可能なバックエンドの一覧
backends = service.backends()
for b in backends:
    print(f"{b.name}: {b.num_qubits} qubits, "
          f"status={'available' if b.status().operational else 'maintenance'}")
 
# 2. Amazon Braket
# pip install amazon-braket-sdk
"""
from braket.aws import AwsDevice
from braket.circuits import Circuit
 
# IonQ の量子コンピュータを使用
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
 
circuit = Circuit()
circuit.h(0).cnot(0, 1)
 
task = device.run(circuit, shots=1000)
result = task.result()
print(result.measurement_counts)
# 料金: ショットあたり $0.01 + タスクあたり $0.30 (IonQ)
"""
 
# 3. Google Quantum AI
# pip install cirq
"""
import cirq
import cirq_google
 
# Google の量子プロセッサを利用
processor = cirq_google.get_engine().get_processor('rainbow')
qubits = cirq.GridQubit.rect(1, 2)
 
circuit = cirq.Circuit(
    cirq.H(qubits[0]),
    cirq.CNOT(qubits[0], qubits[1]),
    cirq.measure(*qubits, key='result'),
)
 
result = processor.run(circuit, repetitions=1000)
"""
 
# 4. Azure Quantum
"""
from azure.quantum import Workspace
from azure.quantum.cirq import AzureQuantumService
 
workspace = Workspace(
    resource_id="/subscriptions/.../quantumWorkspaces/my-workspace",
    location="eastus",
)
 
# Quantinuum の H1 量子コンピュータ
service = AzureQuantumService(workspace=workspace)
# 料金: HQC (Hardware Quantum Credits) 単位
"""
 
# 各サービスの比較
cloud_comparison = {
    "IBM Quantum": {
        "量子ビット数": "127 (Eagle) / 1121 (Condor)",
        "方式": "超伝導",
        "無料枠": "あり（10分/月）",
        "料金": "従量課金 ($1.60/秒)",
        "SDK": "Qiskit",
    },
    "Amazon Braket": {
        "量子ビット数": "IonQ 25, Rigetti 80+",
        "方式": "イオントラップ/超伝導（選択可）",
        "無料枠": "$100相当（新規）",
        "料金": "ショット課金",
        "SDK": "Braket SDK",
    },
    "Google Quantum AI": {
        "量子ビット数": "105 (Willow)",
        "方式": "超伝導",
        "無料枠": "研究者向け申請制",
        "料金": "申請制",
        "SDK": "Cirq",
    },
    "Azure Quantum": {
        "量子ビット数": "Quantinuum H2 56",
        "方式": "イオントラップ他",
        "無料枠": "$500相当（新規）",
        "料金": "HQC単位",
        "SDK": "Q# / Cirq / Qiskit",
    },
}

import random
from typing import List, Tuple
 
class DNAStorage:
    """
    DNAデータストレージのエンコード/デコードシミュレーション
 
    実際のシステムでは以下の追加処理が必要:
    - エラー訂正符号（Reed-Solomon等）
    - GCコンテンツの均一化（40-60%）
    - ホモポリマー回避（AAAA等の連続を避ける）
    - ランダムアクセスのためのアドレス付与
    """
 
    # 2ビット → 1塩基のマッピング
    ENCODE_MAP = {'00': 'A', '01': 'T', '10': 'G', '11': 'C'}
    DECODE_MAP = {v: k for k, v in ENCODE_MAP.items()}
 
    def encode(self, data: bytes) -> str:
        """バイナリデータをDNA塩基配列にエンコード"""
        binary = ''.join(format(byte, '08b') for byte in data)
 
        # 奇数長の場合パディング
        if len(binary) % 2 != 0:
            binary += '0'
 
        # 2ビットずつDNA塩基に変換
        dna = ''
        for i in range(0, len(binary), 2):
            dna += self.ENCODE_MAP[binary[i:i+2]]
 
        return dna
 
    def decode(self, dna: str) -> bytes:
        """DNA塩基配列をバイナリデータにデコード"""
        binary = ''
        for base in dna:
            binary += self.DECODE_MAP[base]
 
        # 8ビットずつバイトに変換
        data = bytearray()
        for i in range(0, len(binary) - len(binary) % 8, 8):
            data.append(int(binary[i:i+8], 2))
 
        return bytes(data)
 
    def add_error_correction(self, dna: str, redundancy: int = 3) -> List[str]:
        """
        冗長性によるエラー訂正
        同じデータを複数のDNA断片にエンコード
        """
        fragment_len = 200  # 典型的なDNA合成の上限長
        fragments = []
 
        for i in range(0, len(dna), fragment_len):
            fragment = dna[i:i + fragment_len]
            # 各断片をredundancy回複製
            for r in range(redundancy):
                # アドレス(位置情報)を付与
                address = format(i // fragment_len, '016b')
                address_dna = ''.join(
                    self.ENCODE_MAP[address[j:j+2]]
                    for j in range(0, 16, 2)
                )
                fragments.append(address_dna + fragment)
 
        return fragments
 
    def simulate_sequencing_errors(self, dna: str,
                                    substitution_rate: float = 0.01,
                                    insertion_rate: float = 0.005,
                                    deletion_rate: float = 0.005) -> str:
        """シーケンシングエラーのシミュレーション"""
        result = []
        bases = ['A', 'T', 'G', 'C']
 
        for base in dna:
            r = random.random()
            if r < deletion_rate:
                continue  # 欠失
            elif r < deletion_rate + insertion_rate:
                result.append(random.choice(bases))  # 挿入
                result.append(base)
            elif r < deletion_rate + insertion_rate + substitution_rate:
                result.append(random.choice([b for b in bases if b != base]))  # 置換
            else:
                result.append(base)
 
        return ''.join(result)
 
# 使用例
storage = DNAStorage()
 
# テキストデータのエンコード
message = "Hello, DNA Storage!"
encoded = storage.encode(message.encode('utf-8'))
print(f"元のデータ: {message}")
print(f"データサイズ: {len(message)} bytes")
print(f"DNA配列: {encoded[:50]}...")
print(f"DNA配列長: {len(encoded)} bases")
 
# デコード
decoded = storage.decode(encoded)
print(f"復元データ: {decoded.decode('utf-8')}")
 
# エラー訂正付きフラグメント生成
fragments = storage.add_error_correction(encoded)
print(f"フラグメント数: {len(fragments)}")
 
# コスト比較（2025年時点の概算）
cost_comparison = {
    "DNA合成（書き込み）": "$0.01-0.10 / 塩基",
    "DNA合成コスト/MB": "~$3,500",
    "DNAシーケンシング（読み出し）": "$0.001 / 塩基",
    "読み出しコスト/MB": "~$350",
    "HDD コスト/MB": "$0.00002",
    "テープストレージ/MB": "$0.00001",
    "損益分岐点": "50年以上の長期保存データ",
}

import numpy as np
 
class ReversibleGates:
    """
    可逆論理ゲートのシミュレーション
    全ての古典計算は可逆ゲートの組み合わせで実現可能
    """
 
    @staticmethod
    def toffoli(a: int, b: int, c: int) -> tuple:
        """
        Toffoliゲート（CCNOTゲート）
        3入力3出力の可逆ゲート
        c' = c XOR (a AND b)
        a, b は変化しない
 
        任意の古典計算をToffoliゲートだけで構成可能
        """
        return (a, b, c ^ (a & b))
 
    @staticmethod
    def fredkin(a: int, b: int, c: int) -> tuple:
        """
        Fredkinゲート（CSWAPゲート）
        a が 1 のとき b と c を交換
        a が 0 のとき何もしない
        """
        if a == 1:
            return (a, c, b)
        return (a, b, c)
 
    @staticmethod
    def reversible_and(a: int, b: int) -> tuple:
        """Toffoliゲートで AND を実装（ancilla bit = 0）"""
        return ReversibleGates.toffoli(a, b, 0)  # (a, b, a AND b)
 
    @staticmethod
    def reversible_or(a: int, b: int) -> tuple:
        """可逆 OR ゲート"""
        # OR = NOT(NOT(a) AND NOT(b))
        # Toffoli + NOT で実装
        na, nb = 1 - a, 1 - b
        _, _, nand = ReversibleGates.toffoli(na, nb, 0)
        return (a, b, 1 - nand)
 
    @staticmethod
    def reversible_full_adder(a: int, b: int, cin: int) -> tuple:
        """
        可逆全加算器
        sum = a XOR b XOR cin
        cout = (a AND b) OR (cin AND (a XOR b))
 
        入力と出力のビット数が同じ → 情報の損失がない
        """
        # 中間結果
        p = a ^ b           # 半加算のsum
        g = a & b           # 半加算のcarry
        s = p ^ cin          # 全加算のsum
        cout = g | (p & cin) # 全加算のcarry
 
        # ancilla bits で情報を保存
        return (a, b, cin, s, cout)
 
# 検証
gates = ReversibleGates()
 
print("Toffoli ゲート真理値表:")
for a in [0, 1]:
    for b in [0, 1]:
        for c in [0, 1]:
            result = gates.toffoli(a, b, c)
            print(f"  ({a}, {b}, {c}) → {result}")
 
print("\n可逆全加算器:")
for a in [0, 1]:
    for b in [0, 1]:
        for cin in [0, 1]:
            result = gates.reversible_full_adder(a, b, cin)
            print(f"  {a}+{b}+{cin} → sum={result[3]}, cout={result[4]}")
 
# エネルギー効率の理論的比較
print("\n--- エネルギー効率の比較 ---")
print(f"ランダウアー限界 (300K): {1.38e-23 * 300 * 0.693:.2e} J/bit")
print(f"現在のCPU (~5nm):        ~{1e-15:.2e} J/bit操作")
print(f"効率比:                   {1e-15 / (1.38e-23 * 300 * 0.693):.0f} 倍のギャップ")
print(f"可逆コンピューティング:   理論上 0 J/bit")

import numpy as np
 
class AnalogIMCSimulator:
    """
    アナログ In-Memory Computing のシミュレーション
    メモリスタクロスバーアレイでの行列乗算を模擬
    """
 
    def __init__(self, rows: int, cols: int,
                 conductance_range: tuple = (1e-6, 1e-4),
                 adc_bits: int = 8,
                 noise_std: float = 0.02):
        """
        Parameters
        ----------
        rows : int
            入力次元（行数）
        cols : int
            出力次元（列数）
        conductance_range : tuple
            コンダクタンスの最小・最大値 (S)
        adc_bits : int
            ADCのビット数（量子化精度）
        noise_std : float
            デバイスノイズの標準偏差
        """
        self.rows = rows
        self.cols = cols
        self.g_min, self.g_max = conductance_range
        self.adc_bits = adc_bits
        self.noise_std = noise_std
 
        # コンダクタンス行列（重みに対応）
        self.G = None
 
    def program_weights(self, weights: np.ndarray):
        """
        ニューラルネットワークの重みをコンダクタンス値にマッピング
        重みの範囲 [-1, 1] → コンダクタンス [g_min, g_max]
 
        差動ペア方式: 正の重みと負の重みを別々のメモリスタで表現
        W = G+ - G-
        """
        # 重みを [0, 1] に正規化
        w_normalized = (weights + 1) / 2
 
        # コンダクタンスにマッピング
        self.G_pos = self.g_min + w_normalized * (self.g_max - self.g_min)
        self.G_neg = self.g_min + (1 - w_normalized) * (self.g_max - self.g_min)
 
    def compute(self, input_voltages: np.ndarray) -> np.ndarray:
        """
        アナログ行列乗算の実行
 
        物理プロセス:
        1. 入力電圧を行線（ワード線）に印加
        2. メモリスタを通る電流: I = V × G（オームの法則）
        3. 列線（ビット線）で電流を集約: I_col = Σ(V_i × G_ij)
        4. ADCでデジタル値に変換
 
        計算時間: O(1) — 全ての乗算が同時に実行
        """
        # 電流計算（理想的）
        I_pos = input_voltages @ self.G_pos
        I_neg = input_voltages @ self.G_neg
 
        # 差動出力
        I_diff = I_pos - I_neg
 
        # デバイスノイズの追加（実際のハードウェアの不完全性）
        noise = np.random.normal(0, self.noise_std * np.abs(I_diff))
        I_noisy = I_diff + noise
 
        # ADC量子化
        output = self._adc_quantize(I_noisy)
 
        return output
 
    def _adc_quantize(self, analog_signal: np.ndarray) -> np.ndarray:
        """ADCによる量子化（ビット数に応じた精度）"""
        levels = 2 ** self.adc_bits
        sig_range = np.max(np.abs(analog_signal)) + 1e-10
        quantized = np.round(analog_signal / sig_range * (levels / 2))
        return quantized / (levels / 2) * sig_range
 
# 使用例: 128次元の行列乗算
imc = AnalogIMCSimulator(rows=128, cols=64, adc_bits=8)
 
# ランダムな重みをプログラム
weights = np.random.randn(128, 64) * 0.1
imc.program_weights(weights)
 
# 入力データ
input_data = np.random.randn(128) * 0.5
 
# アナログ計算
analog_result = imc.compute(input_data)
 
# デジタル計算（比較用）
digital_result = input_data @ weights
 
# 精度比較
error = np.mean(np.abs(analog_result - digital_result) / (np.abs(digital_result) + 1e-10))
print(f"平均相対誤差: {error:.4%}")
# → 8bit ADC で 1-2% の誤差（AI推論には十分な精度）
 
# エネルギー効率
print("\n--- エネルギー効率比較 (128×64 行列乗算) ---")
print(f"GPU (A100):       ~{128*64*2 / 1e12 * 1e6:.2f} μJ  (FP16)")
print(f"アナログIMC:      ~{128*64*0.1e-15 * 1e6:.4f} μJ  (アナログ)")
print(f"効率比:           ~{128*64*2 / 1e12 / (128*64*0.1e-15):.0f}x")

"""
次世代ハードウェアに備えたスキル開発ロードマップ
"""
 
preparation_roadmap = {
    "2025-2026（今すぐ）": {
        "量子": [
            "Qiskit / Cirq / PennyLane のチュートリアルを完了",
            "IBM Quantum の無料枠で実機を体験",
            "線形代数と量子力学の基礎を復習",
            "量子アルゴリズムの入門書を1冊読む",
        ],
        "ニューロモルフィック": [
            "snnTorch でスパイキングNNを実装してみる",
            "Intel Lava フレームワークのチュートリアル",
            "イベントカメラデータセット(N-MNIST等)で実験",
        ],
        "光コンピューティング": [
            "光学シミュレーション（Photontorch等）を試す",
            "光インターコネクトの動向をウォッチ",
        ],
        "共通": [
            "線形代数の復習（行列分解、固有値問題）",
            "情報理論の基礎（エントロピー、符号化）",
            "低ビット量子化、スパース計算の理解",
        ],
    },
    "2027-2028（準備期間）": {
        "量子": [
            "QAOA/VQEでの実問題解決を試行",
            "PQC（ポスト量子暗号）の移行計画を策定",
            "量子クラウドサービスでのベンチマーク",
        ],
        "ニューロモルフィック": [
            "エッジAIプロジェクトでSNNの採用検討",
            "消費電力制約のあるIoTデバイスへの適用",
        ],
        "光": [
            "光AIアクセラレータのベンチマーク参加",
            "データセンターの光インターコネクト導入検討",
        ],
    },
    "2030+（本番期間）": {
        "目標": [
            "量子-古典ハイブリッドアプリケーションの実装",
            "ニューロモルフィックチップの本番導入",
            "光コンピューティングによるAI推論の最適化",
            "次世代アーキテクチャに最適化されたソフトウェア設計",
        ],
    },
}
 
# 判断基準: いつ次世代ハードウェアを採用すべきか
adoption_criteria = {
    "量子コンピュータを検討すべきケース": [
        "組合せ最適化問題で古典が実用時間内に解けない",
        "分子シミュレーションの精度が不足している",
        "暗号セキュリティの長期計画が必要",
        "研究開発予算がある（まだ商用利用は限定的）",
    ],
    "ニューロモルフィックを検討すべきケース": [
        "消費電力が 10mW 以下の制約がある",
        "常時稼働の異常検知・センサー処理が必要",
        "バッテリー駆動デバイスでのAI推論",
        "イベントカメラとの統合（ロボット、自動運転）",
    ],
    "光コンピューティングを検討すべきケース": [
        "データセンターの電力コストが主要課題",
        "大規模AI推論の低レイテンシが必要",
        "GPU間通信がボトルネックになっている",
        "将来の設備投資計画の策定",
    ],
    "まだ古典コンピュータで十分なケース": [
        "一般的なWebアプリケーション開発",
        "標準的な機械学習・深層学習タスク",
        "データベース処理、CRUD操作",
        "95% 以上のソフトウェアエンジニアリング業務",
    ],
}