{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2c7911bb",
   "metadata": {},
   "source": "# Quantum Algoritmalar\n## İnteraktif Öğrenme Kitabı · Qiskit Study Companion\n\n**Mental modeller · Algoritma kartları · Çalışan kod · Karar rehberi**\n\nBu notebook, kapsamlı rehber dokümanın **interaktif** karşılığıdır:\n- Her algoritma ailesi için slogan ve mental model\n- Algoritma kartı (ne sorunu çözer, fikir, ne zaman seçilir, design notu)\n- Hemen altında **çalıştırılabilir Qiskit örneği**\n\n> **Kısa hatırlatma**  \n> VQC = *learn by tuning*  |  QSVC = *classify through a better similarity map*\n\n---\n### Nasıl kullanılır?\n1. Kurulum hücresini çalıştırın (Runtime → Restart session sonrası)\n2. Soldaki içindekiler / TOC ile gezinin\n3. Her bölümde önce metni okuyun, sonra kodu çalıştırın\n4. Parametreleri değiştirip yeniden koşturarak deneyin"
  },
  {
   "cell_type": "markdown",
   "id": "d97725b9",
   "metadata": {},
   "source": "## 0. Kurulum (Colab · Qiskit 2.x)"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2aab94ce",
   "metadata": {},
   "outputs": [],
   "source": "!pip install -q -U \"qiskit>=2.0\" \"qiskit-aer>=0.15\"\n!pip install -q -U matplotlib numpy scipy\nprint(\"Kurulum tamam. Gerekirse Runtime → Restart session.\")"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f50bc01c",
   "metadata": {},
   "outputs": [],
   "source": "import numpy as np\nimport matplotlib.pyplot as plt\n\nimport qiskit\nfrom qiskit import QuantumCircuit, transpile\nfrom qiskit.circuit import Parameter, ParameterVector\nfrom qiskit.quantum_info import SparsePauliOp, Statevector\nfrom qiskit_aer import AerSimulator\nfrom qiskit_aer.noise import NoiseModel, depolarizing_error, ReadoutError\nfrom qiskit.visualization import plot_histogram\nfrom qiskit.transpiler import CouplingMap\nfrom scipy.optimize import minimize as scipy_minimize\n\ntry:\n    from qiskit.circuit.library import zz_feature_map, QFTGate\n    _HAS_FUNC_LIB = True\nexcept ImportError:\n    from qiskit.circuit.library import ZZFeatureMap, QFT\n    _HAS_FUNC_LIB = False\n\nsimulator = AerSimulator()\nprint(f\"Qiskit version : {qiskit.__version__}\")\nprint(f\"Functional lib : {_HAS_FUNC_LIB}\")\nprint(\"Hazır.\")"
  },
  {
   "cell_type": "markdown",
   "id": "d77ed0bc",
   "metadata": {},
   "source": "---\n# 0. Temel Mental Modeller — Algoritma Aileleri\n\nTüm önemli kuantum algoritmaları birkaç büyük **düşünme ailesine** ayrılır.  \nAileyi bilmek, yeni bir algoritmayı hemen konumlandırmanızı sağlar.\n\n| Aile | Slogan / Mental Model | Temsilciler | Klasik karşılık |\n|------|----------------------|-------------|-----------------|\n| **Search & Amplitude** | Doğru cevabı büyüt, yanlışları bastır | Grover, QAE, Quantum Counting | Arama / örnekleme hızlandırma |\n| **Hidden Structure** | Gizli periyodu veya simetriyi ortaya çıkar | Shor, Simon, BV, Deutsch–Jozsa | Periyot / gizli string |\n| **Phase & Simulation** | Doğanın (veya matrisin) evrimini taklit et | QPE, Trotter, VQE | Simülasyon / özdeğer |\n| **Linear & Data / ML** | Denklem veya veriyi kuantumda çöz / temsil et | HHL, Kernel, VQC, QSVC | Lineer cebir / ML |\n| **Variational / Hybrid** | Parametreli devreyi tune ederek maliyeti düşür | VQE, QAOA, VQC | Optimizasyon + öğrenme |\n\n> **Okuma modeli:** Problem gelince önce *“hangi aileye yakın?”* diye sorun.  \n> Sonra o ailenin kartlarına bakın. Ezber yerine **konumlandırma** becerisi kazandırır."
  },
  {
   "cell_type": "markdown",
   "id": "d04772e7",
   "metadata": {},
   "source": "---\n# 1. Hidden Structure / Period Finding\n## Slogan: *Gizli periyodu veya simetriyi ortaya çıkar*\n\nBu aile, fonksiyondaki gizli yapıyı (periyot, gizli string, denge/simetri) **az sorguda** bulur.  \nÇoğu **interferans** (ve QFT) kullanır."
  },
  {
   "cell_type": "markdown",
   "id": "aa701eed",
   "metadata": {},
   "source": "## 1.1 Deutsch–Jozsa\n\n| | |\n|---|---|\n| **Slogan** | Sabit mi, dengeli mi? — tek sorguda |\n| **Ne sorunu çözer?** | Fonksiyonun sabit mi yoksa dengeli mi olduğunu belirlemek |\n| **Temel fikir** | Süperpozisyonda tüm girdiler + interferans → global özellik tek sorguda |\n| **Karmaşıklık** | Klasik en kötü O(2ⁿ⁻¹+1) → Kuantum **O(1)** sorgu |\n| **Dönem** | Eğitimsel / oracular — pratik alan dar |\n| **Ne zaman?** | Öğretim ve oracle modelini anlamak için |\n| **Design notu** | “Global özelliği az örnekle anlama” alıştırması |\n\n**Sunum cümlesi:** *Tek sorguda global özelliği ayırt etmek — kuantum paralellik + interferansın en temiz örneği.*"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1213941a",
   "metadata": {},
   "outputs": [],
   "source": "def deutsch_jozsa_oracle(n: int, kind: str = \"balanced\") -> QuantumCircuit:\n    oracle = QuantumCircuit(n + 1, name=\"Oracle\")\n    if kind == \"constant1\":\n        oracle.x(n)\n    elif kind == \"balanced\":\n        oracle.cx(0, n)\n    return oracle\n\ndef deutsch_jozsa(n: int = 3, kind: str = \"balanced\") -> QuantumCircuit:\n    qc = QuantumCircuit(n + 1, n)\n    qc.x(n)\n    qc.h(range(n + 1))\n    qc.append(deutsch_jozsa_oracle(n, kind).to_gate(), range(n + 1))\n    qc.h(range(n))\n    qc.measure(range(n), range(n))\n    return qc\n\nprint(\"Deutsch–Jozsa sonuçları:\")\nfor kind in [\"constant0\", \"constant1\", \"balanced\"]:\n    qc = deutsch_jozsa(3, kind)\n    counts = simulator.run(transpile(qc, simulator), shots=1024).result().get_counts()\n    zeros = counts.get(\"0\" * 3, 0)\n    verdict = \"SABİT\" if zeros > 512 else \"DENGELİ\"\n    print(f\"  {kind:12s} → {verdict:8s}  {dict(sorted(counts.items()))}\")\n\ndeutsch_jozsa(3, \"balanced\").draw(\"mpl\", fold=-1)"
  },
  {
   "cell_type": "markdown",
   "id": "55649348",
   "metadata": {},
   "source": "## 1.2 Bernstein–Vazirani\n\n| | |\n|---|---|\n| **Slogan** | Gizli bit string’i tek sorguda öğren |\n| **Ne sorunu çözer?** | f(x)=s·x mod 2 formundaki gizli s |\n| **Temel fikir** | Faz kickback ile s doğrudan ölçülebilir hale gelir |\n| **Karmaşıklık** | Klasik O(n) → Kuantum **O(1)** |\n| **Ne zaman?** | Faz ve oracle sezgisini oturtmak için yapı taşı |\n| **Design notu** | Kavramsal köprü; doğrudan ürün özelliği yok |"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22f32b9e",
   "metadata": {},
   "outputs": [],
   "source": "def bernstein_vazirani(secret: str) -> QuantumCircuit:\n    n = len(secret)\n    qc = QuantumCircuit(n + 1, n)\n    qc.x(n)\n    qc.h(range(n + 1))\n    for i, bit in enumerate(secret):\n        if bit == \"1\":\n            qc.cx(i, n)\n    qc.h(range(n))\n    qc.measure(range(n), range(n))\n    return qc\n\nsecret = \"1011\"\nqc = bernstein_vazirani(secret)\ncounts = simulator.run(transpile(qc, simulator), shots=1024).result().get_counts()\nprint(f\"Gizli s = {secret}\")\nprint(f\"Ölçüm   = {counts}\")\nprint(f\"En sık  = {max(counts, key=counts.get)}  (Qiskit little-endian bit sırasına dikkat)\")\nqc.draw(\"mpl\", fold=-1)"
  },
  {
   "cell_type": "markdown",
   "id": "4f475c66",
   "metadata": {},
   "source": "## 1.3 Simon (basitleştirilmiş)\n\n| | |\n|---|---|\n| **Slogan** | Gizli XOR-periyodu bul |\n| **Ne sorunu çözer?** | f(x)=f(y) ↔ y=x⊕s gizli s |\n| **Temel fikir** | Ölçüm s’ye dik vektörler üretir; klasik lineer cebir ile s çözülür |\n| **Karmaşıklık** | Klasik üstel → Kuantum polinom (**exponential separation**) |\n| **Ne zaman?** | Üstel avantaj örneği ve Shor’a hazırlık |\n| **Design notu** | Kriptografi farkındalığı: gizli yapı + kuantum |"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85daa139",
   "metadata": {},
   "outputs": [],
   "source": "def simon_oracle(n: int, s: str) -> QuantumCircuit:\n    oracle = QuantumCircuit(2 * n, name=\"SimonOracle\")\n    for i in range(n):\n        oracle.cx(i, n + i)\n    if s == \"11\" and n == 2:\n        oracle.cx(0, 2)\n        oracle.cx(0, 3)\n    return oracle\n\ndef simon_circuit(n: int = 2, s: str = \"11\") -> QuantumCircuit:\n    qc = QuantumCircuit(2 * n, n)\n    qc.h(range(n))\n    qc.append(simon_oracle(n, s).to_gate(), range(2 * n))\n    qc.h(range(n))\n    qc.measure(range(n), range(n))\n    return qc\n\nqc = simon_circuit(2, \"11\")\ncounts = simulator.run(transpile(qc, simulator), shots=512).result().get_counts()\nprint(\"Simon ölçümleri (s'ye dik vektörler beklenir):\", counts)\nprint(\"Not: Birden fazla koşu + klasik lineer cebir ile s çözülür.\")\nqc.draw(\"mpl\", fold=-1)"
  },
  {
   "cell_type": "markdown",
   "id": "20a4f96a",
   "metadata": {},
   "source": "## 1.4 Shor (kavramsal kart)\n\n| | |\n|---|---|\n| **Slogan** | Periyodu bul → çarpanlara ayır |\n| **Ne sorunu çözer?** | Büyük tamsayıları çarpanlarına ayırmak |\n| **Temel fikir** | Modüler üs alma + QFT → periyot; klasik post-process → çarpanlar |\n| **Karmaşıklık** | Klasik süper-polinom; Shor **polinom** |\n| **Dönem** | Fault-tolerant (çok yüksek kaynak). NISQ’ta yalnızca toy |\n| **Ne zaman?** | Uzun vadeli kriptografi risk analizi |\n| **Design notu** | Güvenlik roadmap’inde post-quantum cryptography referansı |\n\n> Bu notebook’ta tam Shor implementasyonu yok (kaynak yoğun).  \n> QFT + period-finding fikri aşağıdaki QFT ve QPE bölümlerinde somutlaşır."
  },
  {
   "cell_type": "markdown",
   "id": "6d9dcd87",
   "metadata": {},
   "source": "---\n# 2. Search & Amplitude Amplification\n## Slogan: *Doğru cevabı büyüt, yanlışları bastır*\n\nİşaretlenmiş durumların olasılığını artırarak arama veya tahmin yapar.  \nKlasik rastgele denemeye göre **karesel hızlanma (√N)** sağlar."
  },
  {
   "cell_type": "markdown",
   "id": "9e4628ab",
   "metadata": {},
   "source": "## 2.1 Grover\n\n| | |\n|---|---|\n| **Slogan** | İşaretli iğneyi samanlıkta daha hızlı bul |\n| **Ne sorunu çözer?** | Sırasız arama uzayında işaretli öğeyi bulmak |\n| **Temel fikir** | Oracle işaretler → diffusion büyütür. ≈√N iterasyon |\n| **Karmaşıklık** | Klasik O(N) → Kuantum **O(√N)** (optimal) |\n| **Dönem** | FT ağırlıklı; küçük N’de NISQ toy deneme |\n| **Ne zaman?** | Arama uzayı büyük, yapı zayıf, oracle ucuz implement edilebiliyorsa |\n| **Design notu** | Konfigürasyon/test uzayında “işaretle ve bul” düşünme aracı |\n\n**Sunum cümlesi:** *Oracle işaretler, diffusion büyütür — √N adımda iğneyi bulursun.*"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f6fd6b5",
   "metadata": {},
   "outputs": [],
   "source": "def grover_2qubit(marked: str = \"11\", iterations: int = 1) -> QuantumCircuit:\n    n = 2\n    qc = QuantumCircuit(n, n)\n    qc.h(range(n))\n    for _ in range(iterations):\n        # Oracle\n        if marked == \"11\":\n            qc.cz(0, 1)\n        elif marked == \"10\":\n            qc.x(1); qc.cz(0, 1); qc.x(1)\n        elif marked == \"01\":\n            qc.x(0); qc.cz(0, 1); qc.x(0)\n        else:\n            qc.x([0, 1]); qc.cz(0, 1); qc.x([0, 1])\n        # Diffusion\n        qc.h(range(n)); qc.x(range(n)); qc.cz(0, 1); qc.x(range(n)); qc.h(range(n))\n    qc.measure(range(n), range(n))\n    return qc\n\nqc = grover_2qubit(\"11\", iterations=1)\ncounts = simulator.run(transpile(qc, simulator), shots=1024).result().get_counts()\nprint(\"Grover (hedef 11):\", dict(sorted(counts.items(), key=lambda x: -x[1])))\nplot_histogram(counts, title=\"Grover — marked=11\")"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "299aca26",
   "metadata": {},
   "outputs": [],
   "source": "# İterasyon etkisi: fazla iterasyon bozabilir (over-rotation)\nfig, axes = plt.subplots(1, 3, figsize=(11, 3))\nfor i, ax in enumerate(axes):\n    counts = simulator.run(\n        transpile(grover_2qubit(\"11\", iterations=i), simulator), shots=1024\n    ).result().get_counts()\n    ax.bar(list(counts.keys()), list(counts.values()), color=\"#2563eb\")\n    ax.set_title(f\"iter = {i}\"); ax.set_ylim(0, 1100)\nplt.suptitle(\"Grover: iterasyon arttıkça |11⟩ baskınlaşır (sonra bozulabilir)\")\nplt.tight_layout(); plt.show()"
  },
  {
   "cell_type": "markdown",
   "id": "7145c5be",
   "metadata": {},
   "source": "## 2.2 Amplitude Estimation (kavramsal kart)\n\n| | |\n|---|---|\n| **Slogan** | Olasılığı daha az örnekle tahmin et |\n| **Ne sorunu çözer?** | Olay olasılığı / işaretli durum sayısı |\n| **Karmaşıklık** | Klasik O(1/ε²) → Kuantum **O(1/ε)** |\n| **Ne zaman?** | Yüksek doğrulukta olasılık / expectation gerektiğinde |\n| **Design notu** | Risk, kalite kontrol örneklemesi, A/B güç artırımı |"
  },
  {
   "cell_type": "markdown",
   "id": "33f1084f",
   "metadata": {},
   "source": "---\n# 3. Yapıtaşı: Quantum Fourier Transform (QFT)\n\n| | |\n|---|---|\n| **Slogan** | Periyodu / frekansı register’da ortaya çıkar |\n| **Rol** | Shor, QPE ve period-finding ailesinin omurgası |\n| **Karmaşıklık** | O(n²) gate (yaklaşık versiyonlar daha ucuz) |\n| **Not** | Tek başına uygulama değil, alt rutin |"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5c6686b",
   "metadata": {},
   "outputs": [],
   "source": "def qft_circuit(n: int) -> QuantumCircuit:\n    qc = QuantumCircuit(n, name=\"QFT\")\n    for j in range(n):\n        qc.h(j)\n        for k in range(j + 1, n):\n            qc.cp(np.pi / (2 ** (k - j)), k, j)\n    for i in range(n // 2):\n        qc.swap(i, n - 1 - i)\n    return qc\n\nqft3 = qft_circuit(3)\nprint(\"Manuel 3-kübit QFT:\")\nprint(qft3)\n\nif _HAS_FUNC_LIB:\n    lib = QuantumCircuit(3)\n    lib.append(QFTGate(3), range(3))\n    print(\"QFTGate derinlik:\", lib.decompose().depth())\nelse:\n    from qiskit.circuit.library import QFT\n    print(\"QFT(class) derinlik:\", QFT(3, do_swaps=True).decompose().depth())\n\nqft3.draw(\"mpl\", fold=-1)"
  },
  {
   "cell_type": "markdown",
   "id": "52e1be86",
   "metadata": {},
   "source": "---\n# 4. Phase Estimation & Simulation Ailesi\n## Slogan: *Fazı oku, evrimi taklit et*"
  },
  {
   "cell_type": "markdown",
   "id": "143fef73",
   "metadata": {},
   "source": "## 4.1 Quantum Phase Estimation (QPE)\n\n| | |\n|---|---|\n| **Slogan** | Unitary’nin özfazını oku |\n| **Ne sorunu çözer?** | U\\|ψ⟩ = e^{2πiφ}\\|ψ⟩ fazını tahmin |\n| **Temel fikir** | Controlled-U kuvvetleri + ters QFT |\n| **Dönem** | FT ağırlıklı; iterative varyantlar NISQ’a yaklaşır |\n| **Not** | Shor, HHL, kuantum kimyasının ortak omurgası |\n\n**Sunum cümlesi:** *QPE birçok algoritmanın omurgasıdır.*"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de82ca98",
   "metadata": {},
   "outputs": [],
   "source": "def simple_qpe_t_gate(counting_qubits: int = 3) -> QuantumCircuit:\n    \"\"\"T|1⟩ = e^{iπ/4}|1⟩ → φ = 1/8\"\"\"\n    n = counting_qubits\n    qc = QuantumCircuit(n + 1, n)\n    qc.x(n)\n    qc.h(range(n))\n    for k in range(n):\n        qc.cp((np.pi / 4) * (2 ** k), k, n)\n    inv = qft_circuit(n).inverse()\n    qc.append(inv.to_gate(label=\"QFT†\"), range(n))\n    qc.measure(range(n), range(n))\n    return qc\n\nqc = simple_qpe_t_gate(3)\ncounts = simulator.run(transpile(qc, simulator), shots=2048).result().get_counts()\ntop = max(counts, key=counts.get)\nphase_est = int(top, 2) / (2 ** 3)\nprint(f\"En sık: {top}  →  φ ≈ {phase_est:.4f}  (beklenen 0.125)\")\nplot_histogram(counts, title=\"QPE — T kapısı fazı (φ=1/8)\")"
  },
  {
   "cell_type": "markdown",
   "id": "a4e6d2df",
   "metadata": {},
   "source": "## 4.2 VQE — Variational Quantum Eigensolver\n\n| | |\n|---|---|\n| **Slogan** | Hamiltonian enerjisini parametreli devre ile yaklaş |\n| **Ne sorunu çözer?** | Taban durumu enerjisi (özellikle moleküller) |\n| **Temel fikir** | Ansatz → enerji ölç → classical optimizer ile tune |\n| **Dönem** | **NISQ / hybrid** — yakın vadede en gerçekçi kimya yolu |\n| **Güçlü / zayıf** | Donanımda denenebilir · barren plateau, gürültü, ansatz seçimi |\n| **Design notu** | *Learn by tuning* mantığının kimya versiyonu; formülasyon keşfi |\n\n**Sunum cümlesi:** *VQE kimya enerjisi için tune ederek yaklaşır.*"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d191afef",
   "metadata": {},
   "outputs": [],
   "source": "# Mini VQE: H = Z → ideal E = -1, θ = π\ntheta = Parameter(\"θ\")\nansatz = QuantumCircuit(1)\nansatz.ry(theta, 0)\n\ndef energy(theta_val: float, shots: int = 2000) -> float:\n    qc = ansatz.assign_parameters({theta: float(theta_val)})\n    qc_m = qc.measure_all(inplace=False)\n    counts = simulator.run(transpile(qc_m, simulator), shots=shots).result().get_counts()\n    p0 = sum(v for k, v in counts.items() if k[-1] == \"0\") / shots\n    p1 = 1.0 - p0\n    return p0 - p1  # ⟨Z⟩\n\ngrid = np.linspace(0, 2 * np.pi, 24)\nenergies = [energy(t) for t in grid]\nbest = int(np.argmin(energies))\nprint(f\"VQE-benzeri: θ ≈ {grid[best]:.3f}, E ≈ {energies[best]:.4f}  (ideal θ=π, E=-1)\")\n\nplt.figure(figsize=(7, 3.5))\nplt.plot(grid, energies, \"o-\", color=\"#0d9488\")\nplt.axhline(-1, color=\"gray\", ls=\"--\", label=\"ideal -1\")\nplt.axvline(np.pi, color=\"gray\", ls=\":\", label=\"θ=π\")\nplt.xlabel(\"θ\"); plt.ylabel(\"⟨Z⟩\"); plt.title(\"Mini VQE: enerji vs parametre\")\nplt.legend(); plt.grid(True, alpha=0.3); plt.show()"
  },
  {
   "cell_type": "markdown",
   "id": "d0eb4a1a",
   "metadata": {},
   "source": "## 4.3 QAOA\n\n| | |\n|---|---|\n| **Slogan** | Optimizasyon maliyetini katman katman yaklaştır |\n| **Ne sorunu çözer?** | Kombinatoryal optimizasyon (MaxCut vb.) |\n| **Temel fikir** | Cost + mixer Hamiltonian alternatif katmanlar; optimizer parametre ayarlar |\n| **Dönem** | NISQ / hybrid |\n| **Design notu** | Çizelgeleme, yerleşim, portföy kısıtları |"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81920028",
   "metadata": {},
   "outputs": [],
   "source": "gamma, beta = Parameter(\"γ\"), Parameter(\"β\")\nqaoa_qc = QuantumCircuit(2, 2)\nqaoa_qc.h([0, 1])\nqaoa_qc.cx(0, 1); qaoa_qc.rz(2 * gamma, 1); qaoa_qc.cx(0, 1)\nqaoa_qc.rx(2 * beta, [0, 1])\nqaoa_qc.measure([0, 1], [0, 1])\n\nprint(\"QAOA p=1 — MaxCut kenar (0,1); iyi cut = 01 veya 10\")\nfor g, b in [(0.8, 0.4), (1.2, 0.6), (0.5, 0.9)]:\n    bound = qaoa_qc.assign_parameters({gamma: g, beta: b})\n    counts = simulator.run(transpile(bound, simulator), shots=1024).result().get_counts()\n    good = counts.get(\"01\", 0) + counts.get(\"10\", 0)\n    print(f\"  γ={g:.1f}, β={b:.1f}  iyi-cut oranı ≈ {good/1024:.2f}  {dict(sorted(counts.items()))}\")\n\nqaoa_qc.draw(\"mpl\", fold=-1)"
  },
  {
   "cell_type": "markdown",
   "id": "bc8eda75",
   "metadata": {},
   "source": "---\n# 5. Linear Systems & Quantum Data / ML\n## Slogan: *Denklemleri çöz, veriyi farklı bir uzayda temsil et*"
  },
  {
   "cell_type": "markdown",
   "id": "303ba774",
   "metadata": {},
   "source": "## 5.1 HHL (kavramsal kart)\n\n| | |\n|---|---|\n| **Slogan** | Ax=b sistemini kuantumda çöz |\n| **Temel fikir** | QPE ile özdeğerler → 1/λ rotation → \\|x⟩ |\n| **Dönem** | Fault-tolerant; NISQ’ta pratik değil |\n| **Kritik** | Sparsity, condition number, state prep, readout — avantajı kolayca yok eder |\n| **Design notu** | Yakın vadede ürün özelliği zayıf; gelecek ar-ge referansı |"
  },
  {
   "cell_type": "markdown",
   "id": "10384f27",
   "metadata": {},
   "source": "## 5.2 Quantum Kernel & QSVC\n\n| | |\n|---|---|\n| **Slogan** | *Classify through a better similarity map* |\n| **Ne sorunu çözer?** | Kuantum feature map ile similarity/kernel → classical SVM |\n| **Öğrenen kısım** | Classical SVM boundary; quantum tarafı representation |\n| **Dönem** | NISQ uyumlu (kısa feature map) |\n| **Ne zaman?** | Segment / product family / similarity mapping |\n| **Design notu** | Product Design Case Studies omurgası — “Harita değişiyor mu?” |"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7460d340",
   "metadata": {},
   "outputs": [],
   "source": "def make_zz_feature_map(dim: int = 2, reps: int = 1):\n    if _HAS_FUNC_LIB:\n        return zz_feature_map(dim, reps=reps)\n    return ZZFeatureMap(dim, reps=reps)\n\ndef zz_kernel_value(x1, x2, reps: int = 1) -> float:\n    fm = make_zz_feature_map(2, reps)\n    circ = fm.assign_parameters(x1).compose(fm.assign_parameters(x2).inverse())\n    sv = Statevector.from_instruction(circ)\n    return float(np.abs(sv.data[0]) ** 2)\n\nx_a, x_b, x_c = [0.2, 0.5], [0.3, 0.4], [2.5, 2.8]\nprint(f\"K(a,b) ≈ {zz_kernel_value(x_a, x_b):.4f}  (yakın noktalar → yüksek similarity)\")\nprint(f\"K(a,c) ≈ {zz_kernel_value(x_a, x_c):.4f}  (uzak noktalar → düşük)\")\nprint(\"→ Bu değerler kernel matrisini doldurur; classical SVM karar sınırını çizer = QSVC.\")"
  },
  {
   "cell_type": "markdown",
   "id": "c728fbd8",
   "metadata": {},
   "source": "## 5.3 VQC — Variational Quantum Classifier\n\n| | |\n|---|---|\n| **Slogan** | *Learn by tuning* — modelin kendisi öğrenir |\n| **Ne sorunu çözer?** | Parametreli kuantum devreyi optimize ederek sınıflandırma |\n| **Öğrenen kısım** | Quantum circuit parameters (aktif learner) |\n| **Dönem** | NISQ / hybrid |\n| **Ne zaman?** | Davranış / decision logic; feature interaction kritikse |\n| **Design notu** | Smart program logic, kişiselleştirme, circular design trade-off |"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "334cc41c",
   "metadata": {},
   "outputs": [],
   "source": "def vqc_score(x, params):\n    \"\"\"x: 2D özellik, params: [θ0,θ1,θ2] → ⟨Z₀⟩ skoru\"\"\"\n    qc = QuantumCircuit(2)\n    qc.ry(x[0], 0); qc.ry(x[1], 1)\n    qc.ry(params[0], 0); qc.ry(params[1], 1)\n    qc.cx(0, 1)\n    qc.ry(params[2], 0)\n    sv = Statevector.from_instruction(qc)\n    return float(sv.expectation_value(SparsePauliOp.from_list([(\"ZI\", 1.0)])).real)\n\nparams0 = np.array([0.3, 0.5, 0.1])\nprint(\"Örnek skor x=[0.5,0.2]:\", round(vqc_score([0.5, 0.2], params0), 4))\nprint(\"→ Loss = f(skor, etiket); optimizer params'ı tune eder = VQC.\")\nprint(\"→ Gürültü + SPSA + HEA için Noise Resilience notebook'una bakın.\")"
  },
  {
   "cell_type": "markdown",
   "id": "39959f79",
   "metadata": {},
   "source": "### VQC vs QSVC özet tablosu\n\n| | **VQC** | **QSVC** |\n|---|---|---|\n| Mental model | Learn by tuning | Better similarity map |\n| Öğrenen kısım | Quantum circuit parameters | Classical SVM boundary |\n| Optimizer | Merkezde (SPSA, COBYLA…) | Esas optimizasyon classical |\n| Güçlü yan | Adaptive, complex interaction | Representation / segment netliği |\n| Zayıf yan | Training sensitivity, noise | Feature map / kernel kalitesi |\n| Ne zaman | Davranış / decision logic | Family / segment / similarity |"
  },
  {
   "cell_type": "markdown",
   "id": "df3d459e",
   "metadata": {},
   "source": "---\n# 6. NISQ Gerçekleri — Gürültü, Optimizer, Ansatz\n\nYakın vadede çalışacak algoritmaların çoğu **hybrid / variational**.  \nÜç savunma katmanı kritiktir."
  },
  {
   "cell_type": "markdown",
   "id": "ad9f563d",
   "metadata": {},
   "source": "## 6.1 Readout Error Mitigation (confusion matrix mantığı)"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed835de9",
   "metadata": {},
   "outputs": [],
   "source": "def create_readout_noise(p0given1=0.10, p1given0=0.06):\n    nm = NoiseModel()\n    err = ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])\n    nm.add_readout_error(err, [0])\n    return nm\n\nnoisy_backend = AerSimulator(noise_model=create_readout_noise())\n\ndef calibrate_A(backend, shots=8192):\n    def run_prep(bit):\n        qc = QuantumCircuit(1, 1)\n        if bit == 1: qc.x(0)\n        qc.measure(0, 0)\n        return backend.run(qc, shots=shots).result().get_counts()\n    c0, c1 = run_prep(0), run_prep(1)\n    A = np.array([\n        [c0.get(\"0\", 0)/shots, c1.get(\"0\", 0)/shots],\n        [c0.get(\"1\", 0)/shots, c1.get(\"1\", 0)/shots],\n    ])\n    return A\n\nA = calibrate_A(noisy_backend)\nprint(\"Kalibrasyon (confusion) matrisi A:\")\nprint(np.round(A, 3))\nprint(\"→ Klasik ML confusion matrix gibi; A⁻¹ ile ölçüm düzeltilir.\")"
  },
  {
   "cell_type": "markdown",
   "id": "309c72df",
   "metadata": {},
   "source": "## 6.2 Zero-Noise Extrapolation (ZNE) — pure Qiskit"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e7114d3",
   "metadata": {},
   "outputs": [],
   "source": "def execute_with_noise(circuit, shots=2048, p=0.025):\n    nm = NoiseModel()\n    nm.add_all_qubit_quantum_error(depolarizing_error(p, 1), [\"ry\", \"rz\", \"sx\", \"x\"])\n    be = AerSimulator(noise_model=nm)\n    qc = circuit.copy(); qc.measure_all()\n    counts = be.run(qc, shots=shots).result().get_counts()\n    p0 = counts.get(\"0\", 0) / shots\n    p1 = counts.get(\"1\", 0) / shots\n    return p0 - p1\n\ndef fold_ry(theta, scale: int):\n    scale = int(scale) | 1  # tek sayı\n    qc = QuantumCircuit(1)\n    qc.ry(theta, 0)\n    for _ in range((scale - 1) // 2):\n        qc.ry(-theta, 0); qc.ry(theta, 0)\n    return qc\n\ntheta = np.pi / 3\nideal = np.cos(theta)\nscales = [1, 3, 5]\nvals = [execute_with_noise(fold_ry(theta, s)) for s in scales]\ncoeffs = np.polyfit(scales, vals, deg=min(2, len(scales)-1))\nzne = float(np.polyval(coeffs, 0.0))\n\nprint(f\"Ideal: {ideal:.4f}  |  λ=1: {vals[0]:.4f}  |  ZNE: {zne:.4f}\")\nprint(f\"Hata: {abs(vals[0]-ideal):.4f} → {abs(zne-ideal):.4f}\")\n\nxs = [1, 2, 3, 4, 5]\nys = [execute_with_noise(fold_ry(theta, s)) for s in xs]\nplt.figure(figsize=(7, 4))\nplt.plot(xs, ys, \"o-\", label=\"ölçülen\")\nplt.axhline(ideal, ls=\"--\", color=\"green\", label=f\"ideal {ideal:.3f}\")\nplt.axhline(zne, ls=\":\", color=\"red\", label=f\"ZNE {zne:.3f}\")\nplt.xlabel(\"λ\"); plt.ylabel(\"⟨Z⟩\"); plt.title(\"Zero-Noise Extrapolation\")\nplt.legend(); plt.grid(True, alpha=0.3); plt.show()"
  },
  {
   "cell_type": "markdown",
   "id": "33b1712e",
   "metadata": {},
   "source": "## 6.3 Hardware-Efficient Ansatz (SWAP maliyeti)"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4eb801f",
   "metadata": {},
   "outputs": [],
   "source": "coupling = CouplingMap([[0, 1], [1, 0], [1, 2], [2, 1], [1, 3], [3, 1]])\nbasis = [\"rz\", \"sx\", \"x\", \"cx\"]\n\ndef naive_ansatz(n=4):\n    p = ParameterVector(\"θ\", n * 2)\n    qc = QuantumCircuit(n)\n    for i in range(n): qc.ry(p[i], i)\n    for i in range(n):\n        for j in range(i+1, n): qc.cx(i, j)\n    for i in range(n): qc.ry(p[n+i], i)\n    return qc\n\ndef hea_ansatz(n=4):\n    p = ParameterVector(\"θ\", n * 2)\n    qc = QuantumCircuit(n)\n    for i in range(n): qc.ry(p[i], i)\n    for i in range(n-1): qc.cx(i, i+1)\n    for i in range(n): qc.ry(p[n+i], i)\n    return qc\n\nnaive_t = transpile(naive_ansatz(), coupling_map=coupling, basis_gates=basis, optimization_level=1)\nhea_t = transpile(hea_ansatz(), coupling_map=coupling, basis_gates=basis, optimization_level=1)\nprint(f\"Naif  → CNOT: {naive_t.count_ops().get('cx', 0):3d}  derinlik: {naive_t.depth()}\")\nprint(f\"HEA   → CNOT: {hea_t.count_ops().get('cx', 0):3d}  derinlik: {hea_t.depth()}\")\nprint(\"→ HEA, cihaz topolojisine uyduğu için SWAP / ekstra CNOT maliyetini düşürür.\")"
  },
  {
   "cell_type": "markdown",
   "id": "68fee0fd",
   "metadata": {},
   "source": "---\n# 7. Karşılaştırma: NISQ vs Fault-Tolerant\n\n| Algoritma / Aile | NISQ / Hybrid | Fault-Tolerant | Not |\n|------------------|---------------|----------------|-----|\n| VQE, QAOA, VQC | ★★★★★ | ★★ | Yakın vadede en gerçekçi |\n| Quantum Kernels / QSVC | ★★★★ | ★★★ | Kısa feature map ile denenebilir |\n| Grover (küçük N) | ★★ | ★★★★★ | Toy ölçek NISQ |\n| QAE (iterative) | ★★★ | ★★★★★ | Variational sürümler NISQ’a yaklaşır |\n| QPE, Shor, HHL | ★ | ★★★★★ | Yüksek kaynak; uzun vadeli |\n| QSVT / Qubitization | ★ | ★★★★★ | Modern FT algoritma dili |"
  },
  {
   "cell_type": "markdown",
   "id": "0e12f3e4",
   "metadata": {},
   "source": "---\n# 8. Karar Rehberi — Hangi durumda hangi aile?\n\n### Sorular (ezber → muhakeme)\n1. Arama uzayım yapısal olarak boş mu, yoksa gizli periyot/simetri var mı? → **Search vs Hidden Structure**\n2. Faz, özdeğer veya zaman evrimi mi kritik? → **Phase / Simulation**\n3. Model parametrelerini tune ederek mi öğreneceğim, yoksa similarity map mi? → **VQC vs QSVC**\n4. Kombinatoryal optimizasyon mu, enerji/taban durumu mu? → **QAOA vs VQE**\n5. Yakın vadede (NISQ) mi, uzun vadeli (FT) mi planlıyorum?\n6. Çıktı olarak tam çözüm mü, yoksa özellik / olasılık / segment mi yeterli?\n\n### Hızlı seçim\n\n| İhtiyacınız | Önce bakın | Dikkat |\n|-------------|------------|--------|\n| Yapısal olmayan arama | Grover / Amplitude | Oracle maliyeti, N |\n| Periyot / çarpan / gizli string | Simon → Shor | FT kaynak |\n| Moleküler / malzeme enerjisi | VQE | Ansatz, ölçüm, barren plateau |\n| Kombinatoryal optimizasyon | QAOA | Embedding, p derinliği |\n| Sınıflandırma / segment | VQC veya QSVC | Case study karar rehberi |\n| Olasılık / risk tahmini | Amplitude Estimation | State prep |\n| Lineer sistem özelliği | HHL ailesi | Şartlar çok kısıtlayıcı |"
  },
  {
   "cell_type": "markdown",
   "id": "7e391202",
   "metadata": {},
   "source": "---\n# 9. Product Design ile Bağlantı\n\n| Düşünme aracı | Product design anlamı |\n|---------------|----------------------|\n| **Search / Grover** | Büyük konfigürasyon veya test uzayında “işaretli/uygun” adayları daha az denemeyle bulma |\n| **VQE / Simülasyon** | Malzeme, formülasyon, batarya, filtre kimyası R&D pipeline’ı |\n| **QAOA** | Çizelgeleme, yerleşim, kısıtlı portföy, üretim planı |\n| **Kernel / QSVC** | Product family, segment, “similar vs novel” ayrımı |\n| **VQC** | Ürün decision logic, kişiselleştirme, trade-off öğrenme |\n\n> Ürün tasarımında en doğru kullanım çoğu zaman algoritmaları **rakip değil, farklı düşünme araçları** olarak görmekten geçer.  \n> Önce soruyu netleştirin; sonra aile ve kart seçin."
  },
  {
   "cell_type": "markdown",
   "id": "cb11d25f",
   "metadata": {},
   "source": "---\n# 10. Takeaway\n\n1. Algoritmaları tek tek ezberlemek yerine **aile mental modelleri** ile konumlandırın.\n2. Her algoritma için “ne sorunu çözer / temel fikir / ne zaman seçilir / design notu” dörtlüsünü sorun.\n3. NISQ döneminde variational + kernel (VQE, QAOA, VQC, QSVC) en gerçekçi alandır; Shor/HHL/tam QPE uzun vadeli FT vizyonudur.\n4. Gürültü, optimizer ve hardware-efficient ansatz, variational modellerde algoritmanın kendisi kadar kritiktir.\n5. Product design’da soru önce gelir: davranış mı, harita mı, arama mı, enerji mi, optimizasyon mu?\n\n---\n\n| Slogan | Anlam |\n|--------|--------|\n| **VQC** | Bu davranışı öğrenebilir miyiz? |\n| **QSVC** | Bu ürünleri daha anlamlı bir haritada ayırabilir miyiz? |\n| **Grover** | İşaretli olanı daha az denemeyle bulabilir miyiz? |\n| **VQE / QAOA** | Enerjiyi veya maliyeti tune ederek yaklaşabilir miyiz? |\n| **QPE / Shor** | Fazı / periyodu okuyabilir miyiz? (uzun vadeli FT) |\n\n---\n*QML Study Companion · İnteraktif Öğrenme Kitabı · 2026*  \n*Uyumluluk: PDF Rehber · Product Design Case Studies · Noise Resilience Notebook · Qiskit 2.x*"
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}