{
 "nbformat": 4,
 "nbformat_minor": 5,
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "title"
   },
   "source": "# 🔄 Klasik Verinin Kuantum Kodlanması (Data Encoding)\n## Qiskit ile Detaylı Öğrenci Notebook’u\n\n**Soru:** Klasik bir sayıyı, vektörü veya veri setini kuantum bilgisayara nasıl “yükleriz”?\n\nKuantum devreleri **qubit durumları** ve **üniter kapılar** ile çalışır. Klasik veriyi bu dile çevirmeye **encoding / embedding / feature map** denir.\n\n| Bölüm | Konu |\n|-------|------|\n| 1 | Kurulum |\n| 2 | Neden encoding gerekir? |\n| 3 | Basis encoding |\n| 4 | Angle encoding (RX / RY / RZ) |\n| 5 | Dense angle encoding |\n| 6 | Amplitude encoding |\n| 7 | Hamiltonian / Phase encoding |\n| 8 | Feature maps (ZZFeatureMap, Pauli) |\n| 9 | Karşılaştırma tablosu + pratik seçim rehberi |\n| 10 | Mini uçtan uca örnek (2 özellik → sınıflandırma hazırlığı) |\n\n> Tüm örnekler Qiskit + Aer simülatörü ile Colab’da çalışır.\n",
   "id": "title"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s1"
   },
   "source": "## 1. Ortam Kurulumu\n",
   "id": "s1"
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "setup",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655085187,
     "user_tz": -180,
     "elapsed": 19695,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "dcdab878-0afb-4111-cef6-b8a61ed59d83"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Python: 3.13.15\n",
      "Mounted at /content/drive\n",
      "✅ Kurulum tamam.\n"
     ]
    }
   ],
   "source": "import sys\nprint(f\"Python: {sys.version.split()[0]}\")\ntry:\n    from google.colab import drive\n    drive.mount(\"/content/drive\")\nexcept Exception as e:\n    print(\"Drive atlandı:\", e)\n\n!pip install -q --upgrade pip\n!pip install -q qiskit qiskit-aer qiskit-machine-learning\n!pip install -q numpy matplotlib pandas\n\nprint(\"✅ Kurulum tamam.\")\n",
   "id": "setup"
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "imports",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655085212,
     "user_tz": -180,
     "elapsed": 21,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "8a015ae5-b816-49cd-84d6-05587ca128eb"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "✅ Kütüphaneler hazır.\n"
     ]
    }
   ],
   "source": "import numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom qiskit import QuantumCircuit, transpile, QuantumRegister, ClassicalRegister\nfrom qiskit_aer import AerSimulator\nfrom qiskit.quantum_info import Statevector\nfrom qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere\nfrom qiskit.circuit.library import ZZFeatureMap, PauliFeatureMap, RealAmplitudes\n\nsim = AerSimulator()\nnp.set_printoptions(precision=4, suppress=True)\nprint(\"✅ Kütüphaneler hazır.\")\n",
   "id": "imports"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s2"
   },
   "source": "## 2. Neden Encoding Gerekir?\n\nKlasik bilgisayar: `x = 0.7` → bellek adresi + float bitleri.\n\nKuantum bilgisayar:\n- Temel birim **qubit**: $|\\psi\\rangle = \\alpha|0\\rangle + \\beta|1\\rangle$\n- Bilgi **genlik** ve **faz**ta taşınır\n- Ölçüm sonucu olasılıksaldır\n\nBu yüzden klasik $x$ değerini şu formlardan birine map’leriz:\n\n1. **Basis** → bit string → $|b_1 b_2 \\ldots b_n\\rangle$\n2. **Angle** → rotasyon açısı → $R_y(x)|0\\rangle$\n3. **Amplitude** → durum vektörü genlikleri → $\\sum x_i |i\\rangle$\n4. **Feature map** → Hilbert uzayında doğrusal olmayan gömme\n\nEncoding seçimi: veri tipi, qubit sayısı, derinlik, gürültü toleransı.\n",
   "id": "s2"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s3"
   },
   "source": "## 3. Basis Encoding\n\n**Fikir:** Klasik tamsayı / bit dizisini doğrudan hesaplama tabanına yaz.\n\nÖrnek: sayı `5` → ikili `101` → durum $|101\\rangle$\n\n**Artı:** Basit, anlaşılır, kesin.  \n**Eksi:** $n$ bit için $n$ qubit; sürekli veride önce kuantizasyon gerekir.\n",
   "id": "s3"
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "basis",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655085222,
     "user_tz": -180,
     "elapsed": 7,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "c2c71b60-9d96-4f58-ff00-ba1cf1311723"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Klasik değer: 5 → ikili: 101 → kuantum: |101>\n",
      "     ┌───┐\n",
      "q_0: ┤ X ├\n",
      "     └───┘\n",
      "q_1: ─────\n",
      "     ┌───┐\n",
      "q_2: ┤ X ├\n",
      "     └───┘\n",
      "\n",
      "Statevector (sadece |101> = index 5 non-zero olmalı):\n",
      "[0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      "Olasılıklar: [0. 0. 0. 0. 0. 1. 0. 0.]\n"
     ]
    }
   ],
   "source": "def basis_encode_integer(value: int, n_qubits: int) -> QuantumCircuit:\n    \"\"\"Tamsayıyı n qubit basis state olarak kodla.\"\"\"\n    bits = format(value, f\"0{n_qubits}b\")\n    qc = QuantumCircuit(n_qubits, name=f\"basis|{bits}>\")\n    # Qiskit: qubit 0 = en sağ bit (little endian çizimde dikkat)\n    for i, b in enumerate(reversed(bits)):\n        if b == \"1\":\n            qc.x(i)\n    return qc, bits\n\nvalue = 5\nn = 3\nqc_basis, bits = basis_encode_integer(value, n)\nprint(f\"Klasik değer: {value} → ikili: {bits} → kuantum: |{bits}>\")\nprint(qc_basis.draw(output=\"text\"))\n\nsv = Statevector.from_instruction(qc_basis)\nprint(\"\\nStatevector (sadece |101> = index 5 non-zero olmalı):\")\nprint(np.round(sv.data, 4))\nprint(f\"Olasılıklar: {np.round(np.abs(sv.data)**2, 4)}\")\n",
   "id": "basis"
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "basis_features",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655085247,
     "user_tz": -180,
     "elapsed": 22,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "f813f4da-cee2-4715-8644-a6c2164b4dd6"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Özellikler [0.1, 0.9] → bit string 0011\n",
      "          \n",
      "q_0: ─────\n",
      "          \n",
      "q_1: ─────\n",
      "     ┌───┐\n",
      "q_2: ┤ X ├\n",
      "     ├───┤\n",
      "q_3: ┤ X ├\n",
      "     └───┘\n",
      "Yoğun durum indeksi: 3 | genlik karesi orada: 0.0\n"
     ]
    }
   ],
   "source": "# Birden fazla özelliği bitlere bağlama (ör: iki 2-bit özellik)\ndef basis_encode_features(features, bits_per_feature=2):\n    \"\"\"Her özelliği [0,1] aralığında varsayıp kuantize et, sonra bitlere yaz.\"\"\"\n    n = len(features) * bits_per_feature\n    qc = QuantumCircuit(n, name=\"basis_features\")\n    levels = 2 ** bits_per_feature\n    bit_string = \"\"\n    for i, x in enumerate(features):\n        x = float(np.clip(x, 0, 1))\n        idx = min(int(x * levels), levels - 1)\n        local = format(idx, f\"0{bits_per_feature}b\")\n        bit_string += local\n        for j, b in enumerate(reversed(local)):\n            if b == \"1\":\n                qc.x(i * bits_per_feature + j)\n    return qc, bit_string\n\nfeats = [0.1, 0.9]  # düşük / yüksek\nqc_f, bs = basis_encode_features(feats, bits_per_feature=2)\nprint(f\"Özellikler {feats} → bit string {bs}\")\nprint(qc_f.draw(output=\"text\"))\nsv = Statevector.from_instruction(qc_f)\nprint(\"Yoğun durum indeksi:\", int(bs, 2), \"| genlik karesi orada:\", float(np.abs(sv.data[int(bs, 2)])**2))\n",
   "id": "basis_features"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s4"
   },
   "source": "## 4. Angle Encoding (En yaygın pratik yöntem)\n\n**Fikir:** Klasik skaler $x$ → rotasyon açısı.\n\n$$\nR_y(x)|0\\rangle = \\cos(x/2)|0\\rangle + \\sin(x/2)|1\\rangle\n$$\n\nBenzer şekilde $R_x$, $R_z$ kullanılabilir.\n\n- 1 özellik ≈ 1 qubit (veya tekrarlı katmanlarla daha zengin)\n- Sürekli veriye doğal uyum\n- QML’de (VQC, QSVC) en sık kullanılan aile\n",
   "id": "s4"
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "angle_ry",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 153
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655085259,
     "user_tz": -180,
     "elapsed": 10,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "5f418420-624d-4df6-e160-c0bb4ce1c4cd"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Angle encoding RY: [0.5, 1.8]\n",
      "     ┌─────────┐\n",
      "q_0: ┤ Ry(0.5) ├\n",
      "     ├─────────┤\n",
      "q_1: ┤ Ry(1.8) ├\n",
      "     └─────────┘\n",
      "Statevector: [0.6023+0.j 0.1538+0.j 0.759 +0.j 0.1938+0.j]\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {}
    }
   ],
   "source": "def angle_encode_ry(x_list):\n    \"\"\"Her x_i için bir qubit, RY(x_i).\"\"\"\n    n = len(x_list)\n    qc = QuantumCircuit(n, name=\"angle_RY\")\n    for i, x in enumerate(x_list):\n        qc.ry(float(x), i)\n    return qc\n\n# Örnek: iki özellik\nx = [0.5, 1.8]\nqc_ang = angle_encode_ry(x)\nprint(\"Angle encoding RY:\", x)\nprint(qc_ang.draw(output=\"text\"))\n\nsv = Statevector.from_instruction(qc_ang)\nprint(\"Statevector:\", np.round(sv.data, 4))\n\n# Bloch üzerinde tek qubit\nqc1 = angle_encode_ry([1.2])\nsv1 = Statevector.from_instruction(qc1)\nplot_bloch_multivector(sv1)\nplt.suptitle(\"Tek özellik x=1.2 → RY(1.2)|0>\")\nplt.show()\n",
   "id": "angle_ry"
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "angle_axes",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 391
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655085841,
     "user_tz": -180,
     "elapsed": 557,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "487949de-d819-4040-b00c-7a76d6d754da"
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 1200x350 with 3 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAFUCAYAAAD1S49QAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQ2pJREFUeJzt3Xt8z/X///H7e5sdTJtpbM6TFEZoss8cQo1Vi3xDSE4hiaQlEjmWKX1ERUtOfVZ+fCjqgzAiPuUTkY4OETm1OW9yGtvz94fL3nl7b3vvPfPaxu16ubwvF57v5+v1er7fe+/12PP+fh1sxhgjAAAAAAAAwEIehT0AAAAAAAAA3HwIpQAAAAAAAGA5QikAAAAAAABYjlAKAAAAAAAAliOUAgAAAAAAgOUIpQAAAAAAAGA5QikAAAAAAABYjlAKAAAAAAAAliOUAgAAAAAAgOUIpW5Ab7zxhmrWrKnMzEzLt/3SSy8pMjLSsu3t27dPNptNb775Zq791q1bJ5vNpnXr1rm1/rCwMPXs2TNPfQ8cOCBfX199/fXXDu0DBw6UzWaTJC1atCjbcYwZM8bex109e/ZUqVKlJElvvvmmbDab9u3bl691XS89e/ZUWFiYZdvL6/v5119/qXTp0tq2bZvS09M1Z84c3XPPPS6X+/XXX+Xl5aWff/65IIYLFIqHHnpIffv2LZRt/+Mf/9DQoUMt297cuXNls9n03Xff5dovP/virDo0d+7cPPX/97//rTJlyuivv/5yaK9Tp45atGghybFuXKlFixb2Pu4KCwvTww8/LEl6+OGHLd0n55U7Nbcg5PX9XLp0qRo1aqQ///xTZ86c0VNPPaUXX3zR5XIJCQmqUqWKLly4UACjBQoH8wpnzCsKF/OKGw+hlMWy/jDOenh5ealixYrq2bOnDh065ND3yJEjKlOmjO677z6n9Vy8eFF169ZVWFiYzpw5Y29PS0vT66+/rmHDhsnD4+8f74IFC/TEE0+oRo0astlsbv1Re+DAAY0dO1aNGjVSUFCQgoOD1aJFC61evdqp7+DBg/XDDz/o888/z/P682L58uUaM2ZMga6zoI0bN06RkZFq0qSJQ3uPHj2UmJgoSWrUqJESExNVq1atAttuv379NGvWLElSbGysEhMTVbZs2QJb/42sVKlSat++vRo0aCAfHx/16dNHAwYMcLlc7dq1FRsbq1GjRlkwStzM8lIz9u7dq5IlS6pLly7ZrmPBggWy2WyaNm2ave3rr7/WqlWrNGzYMIe+r732mtq2bauQkBDZbDa39rubN2/WwIEDFR4eLn9/f1WpUkWPPfaYdu3a5dR32LBhmjZtmpKTk/O8/ryYPn16nsOhwpCRkaHRo0fr2Weftf/Rn2XixIkaMWKEJMe6UVCmTJmiIUOGSJKGDBmiKVOmFOj6b2T33Xefzp07pwoVKqhUqVJasGCBevTo4XK5nj17Kj09Xe+//74Fo8TNyJ15xdV9c3pcGUAwryg8zCuKH+YV18DAUnPmzDGSzLhx40xiYqL54IMPTO/evY2np6epXr26OXfunEP/GTNmGElm7ty5Du3x8fFGkvnPf/7j0P7WW2+ZgIAAp/U0b97clCpVyrRs2dIEBQWZ5s2b53nM77zzjvHz8zNdunQx7777rpkyZYq5++67jSQze/Zsp/6PPfaYadasWZ7XnxcDBgww2X1c9+7daySZSZMm5bp8RkaGOXfunMnIyHBru+fPnzfp6eku+x05csSUKFHCzJs3z631Zxk9enS2r+9G0aNHD1O1alXLtufu+/m///3PfPLJJ2bXrl15Xmb58uVGktm9e3d+hgjkSV5rxsSJE40ks3LlSoflU1NTTfny5U1kZKTD/u+RRx4xrVu3dtqeJBMaGmpiYmKMJDN69Og8j7V9+/YmNDTUPPvss+aDDz4w48ePNyEhIcbf39/89NNPDn0zMjJMaGioeeWVV9x4N1wLDw/Ptr5lvY+bN2/OdfmLFy861U9XMjMzzblz58ylS5dc9l28eLGx2Wzm4MGDbm0jS/Pmzd2q38VN1apVTY8ePSzbnjvv54ULF8yqVavMZ599Zo4ePZrnbQwdOtRUrVrVZGZm5nOUQM7cmVfs2bPHJCYmZvuYOHGisdlsplq1aubMmTP2ZZhXZI95ReFiXnHjuXE/rUVUTn8YDxs2zEgyCxYscGjPzMw0TZs2NcHBwebYsWPGGGN+//134+fnZx599FGn9d91113miSeecGrfv3+/fceZ0x/tOfn555+d/gA7f/68qVmzpqlUqZJT/0WLFhmbzWb27NmT5224cq3F43qbPHmy8fPzM6dPn87X8hSPgmXF+5menm6CgoIKfFINXCmvNePixYumbt26pnr16ubs2bP2fgMHDjReXl7mhx9+sLelpKQYLy8vM3PmTKft7d271xhjzNGjR90Opb7++mtz4cIFh7Zdu3YZHx8f07VrV6f+AwcOLPDJ+rWGUtdb27ZtTdOmTfO9PKFUwbLi/fzuu++MJLNmzZrruh3cnNydV2Tn0qVL5t577zUlSpQw//vf/xyeY15ROJhX5I55xY2H0/eKiGbNmkmS9uzZ49Bus9mUkJCg1NRU+2H3zzzzjLy8vPT222879N27d69+/PFHRUdHO62/cuXKDofduiM8PFzBwcEObT4+PnrooYd08OBBnT592uG5rO1/9tlneVr/F198oWbNmsnf31+33HKLYmNj9csvv9if79mzp/20kysPL86JMUZPPfWUvL299emnn0rK/tzv3377Te3bt1doaKh8fX1VqVIlde7cWampqfY+eT33e8mSJYqMjHQ6HUOSFi5cqIiICPn5+Sk4OFhPPPGE0yHVOfnoo4/UqFEjlSxZUkFBQbr33nu1atUq+/M5nV5z9bizDtn+73//q0GDBqls2bIqXbq0+vXrp/T0dJ06dUrdu3dXUFCQgoKCNHToUBlj8jTG6dOnKzw8XD4+PqpQoYIGDBigU6dOuVzuzTffVOPGjXXrrbfKz89PERERWrRokVO/pKQkNW3aVKVLl1apUqV055136uWXX7Y/n9fruWT3s/zxxx/VvHlz+fn5qVKlSnr11Vc1Z84cp8PXs7vuSIkSJdSiRYs8f86BgnR1zfDy8tKMGTO0d+9evfrqq5KkLVu2aPr06XrhhRd011132ZddtmyZLl26lG2tuJZrNDRu3Fje3t4ObTVq1FB4eLi2b9/u1L9Vq1b6448/tG3bNpfrzszM1JQpUxQeHi5fX1+FhISoX79+OnnypMPYf/nlF3311Vf2OpHbKSUnT55Uo0aNVKlSJe3cuVNS9teNKKh90Pnz57VixYps3/dLly5p/Pjxql69unx8fBQWFqaXX345T9ciOn/+vMaMGaM77rhDvr6+Kl++vB599FH7ZyOna59kN+6sa4ns379fDz/8sEqVKqWKFSvaa/BPP/2k++67T/7+/qpatarmzZvncnySdObMGb3wwguqXLmyfHx8dOedd+rNN990WWdOnDihIUOGqG7duipVqpQCAgL04IMP6ocffnDq+8477yg8PNxeLxs2bOgwvqw6mNu1UXL6WS5cuFC1a9eWr6+v6tSpo8WLF2d7TZPsanJERITKlClDrYClcppXZGfs2LFav369Xn31VYfrNzGvuIx5BfOK7DCvKFhehT0AXJb1QQ0KCnJ6Ljw8XEOGDFF8fLxuueUWrVixQlOnTlXFihUd+n3zzTeSpLvvvvu6j1eSkpOTVbJkSZUsWdKhPTAwUNWrV9fXX3+t559/Ptd1JCYmqkePHoqJidHrr7+us2fP6r333lPTpk31/fffKywsTP369dPhw4eVlJTk8hobGRkZevLJJ7VgwQItXrxYsbGx2fZLT09XTEyMLly4oGeffVahoaE6dOiQli5dqlOnTikwMDDP78PFixe1efNm9e/f3+m5uXPnqlevXrrnnnsUHx+vlJQUTZ06VV9//bW+//57lS5dOsf1jh07VmPGjFHjxo01btw4eXt769tvv9WXX36p1q1b53l8V8p6rWPHjtX//vc/zZgxQ6VLl9Y333yjKlWqaMKECVq+fLkmTZqkOnXqqHv37rmub8yYMRo7dqyio6PVv39/7dy5U++99542b96sr7/+WiVKlMhx2alTp6pt27bq2rWr0tPTNX/+fHXs2FFLly61/9x++eUXPfzww7rrrrs0btw4+fj4aPfu3U4XfcyPQ4cOqWXLlrLZbBo+fLj8/f01c+ZM+fj45HkdERER+uyzz5SWlqaAgIBrHhOQV9nVjH/84x/q37+/Jk2apM6dO6tfv34KCwvT6NGjHZb95ptvdOutt6pq1arXfZzGGKWkpCg8PNzpuYiICEmXr2/VoEGDXNfTr18/+/500KBB2rt3r9599119//339n3NlClT7Ndqyro2U0hISLbrO3bsmFq1aqUTJ07oq6++UvXq1bPtV5D7oC1btig9PT3bGt2nTx99+OGH6tChg1544QV9++23io+P1/bt27V48eIc15mRkaGHH35Ya9asUefOnfXcc8/p9OnTSkpK0s8//5zj68pNRkaGHnzwQd17771644039PHHH2vgwIHy9/fXiBEj1LVrVz366KNKSEhQ9+7dFRUVpWrVquW4PmOM2rZtq7Vr16p3796qX7++Vq5cqRdffFGHDh3SW2+9leOyv//+u5YsWaKOHTuqWrVqSklJ0fvvv6/mzZvr119/VYUKFSRJH3zwgQYNGqQOHTroueee0/nz5/Xjjz/q22+/1eOPP+72e3ClZcuWqVOnTqpbt67i4+N18uRJ9e7d2+lvsNzcfffdBVK3gLzKbV5xpS+//FKvvfaaYmJinC7ez7yCeYUrzCv+xrziGhXiUVo3pazDbFevXm2OHj1qDhw4YBYtWmTKli1rfHx8zIEDB7Jd7uzZs+a2224zkkxERES2164YOXKkkeTyUE93D7PNzm+//WZ8fX1Nt27dsn2+devWplatWrmu4/Tp06Z06dKmb9++Du3JyckmMDDQoT0vh9levHjRdOrUyfj5+TldV2Xt2rVGklm7dq0xxpjvv//eSDILFy7MdYx5OZVg9+7dRpJ55513HNrT09NNuXLlTJ06dRzOxV+6dKmRZEaNGmVvu/qw0N9++814eHiY//u//3M6X/3KU12Uw+k1V48763MXExPjsHxUVJSx2Wzm6aeftrddunTJVKpUyeVn5MiRI8bb29u0bt3aYYzvvvuu03UBsjvM9spTjIy5/H7VqVPH3Hffffa2t956y0jK9fodWZ+BOXPm2NuyO8z26vfk2WefNTabzXz//ff2tuPHj5syZcoYSfbTmIzJ+RSPefPmGUnm22+/zXF8wLVwt2akpqaaChUq2D/HK1ascFpn06ZNTURERK7bzc/pe9lJTEw0ksysWbOyfd7b29v0798/13Vs2LDBSDIff/yxQ/uKFSuc2vNy+t6ff/5pwsPDzW233Wb27dvn0O/qfUd+90HZmTlzppHkdH2tbdu2GUmmT58+Du1DhgwxksyXX35pb7t6XzR79mwjyUyePNlpe1n7+qvrX27j7tGjh5FkJkyYYG87efKk8fPzMzabzcyfP9/evmPHjjx9RpYsWWIkmVdffdWhvUOHDsZmszlcP+Pq/fT58+edauDevXuNj4+PGTdunL3tkUceMeHh4bmOI+szkNu+Pbv3pG7duqZSpUoOf1utW7fOSHKqazm9H0899ZTx8/PLdXxAfuR3XmHM5VO5y5cvb0JDQ01KSorT88wrmFfkNG7mFcwrChqn7xWS6OholS1bVpUrV1aHDh3k7++vzz//XJUqVcq2v7e3tz1lv//+++Xp6enU5/jx4/Ly8sr2UM+CdPbsWXXs2FF+fn6aOHFitn2CgoJ07NixXNeTlJSkU6dOqUuXLjp27Jj94enpqcjISK1duzbPY0pPT7en4cuXL3eZ+Ge9lytXrtTZs2fzvJ3sHD9+XJLzt1Hfffedjhw5omeeeUa+vr729tjYWNWsWVPLli3LcZ1LlixRZmamRo0a5XR4dH5v8SpJvXv3dlg+MjJSxhj17t3b3ubp6amGDRvq999/z3Vdq1evVnp6ugYPHuwwxr59+yogICDX1ydJfn5+9n+fPHlSqampatasmbZu3Wpvz/rG57PPPivwWxGvWLFCUVFRql+/vr2tTJky6tq1a57XkfUzd/VZB65VXmtGQECApkyZohMnTqhTp06KiYlxWtfx48ddfnteEHbs2KEBAwYoKioqxzuV5aVWLFy4UIGBgWrVqpVDrYiIiFCpUqXcqhUHDx5U8+bNdfHiRa1fv97l0WIFuQ/KqVYsX75ckhQXF+fQ/sILL0hSrvvSTz75RMHBwXr22WednruWWtGnTx/7v0uXLq0777xT/v7+euyxx+ztd955p0qXLu2yVixfvlyenp4aNGiQQ/sLL7wgY4y++OKLHJf18fGx15eMjAwdP37cfrrF1bXi4MGD2rx5s1uv05XDhw/rp59+Uvfu3R3+tmrevLnq1q2b5/UEBQXp3Llz1/z3BpATd+cVxhh1795dKSkpSkxMVLly5Zz6MK9gXuEK84q/Ma+4NoRShWTatGlKSkrSokWL9NBDD+nYsWO5Ht43depUff/996pTp47efvtt7d6928LR/i0jI0OdO3fWr7/+qkWLFtkPnb+aMcblTu63336TdPlWy2XLlnV4rFq1SkeOHMnzuOLj47VkyRItWrQoT7elrVatmuLi4jRz5kwFBwcrJiZG06ZNczjv213mqnOl//jjD0mX/3C/Ws2aNe3PZ2fPnj3y8PBQ7dq18z2e7FSpUsXh/1lFtHLlyk7tV16rJTs5vT5vb2/ddtttub4+SVq6dKn+8Y9/yNfXV2XKlFHZsmX13nvvOfwMOnXqpCZNmqhPnz4KCQlR586d9e9//7tACskff/yh22+/3ak9u7acZP3Mr6WgA3nhTs245557JEkNGzbMcX1X768KWnJysmJjYxUYGKhFixZl+0VK1jjyUitSU1NVrlw5p1rx119/uVUrunXrpiNHjuirr77K0+lX12MflF2t8PDwcNr3hIaGqnTp0i5rxZ133ikvr4K7GoOvr6/T7b8DAwNVqVIlp59VXmtFhQoVdMsttzi0Z93CPLfXl5mZqbfeeks1atSQj4+PgoODVbZsWf34448OtWLYsGEqVaqUGjVqpBo1amjAgAEFcjpG1tioFSjq3J1XvP7661q5cqWGDRuW7TWjrMK8ImfMKy5jXnFzIJQqJI0aNVJ0dLTat2+vzz//XHXq1NHjjz+uv/76y6nvgQMHNHr0aLVr106rVq2St7e3BgwY4NTv1ltv1aVLl5wuEFiQ+vbtq6VLl2ru3Lm67777cux38uRJp4sYXi1rB5CYmKikpCSnhzsXeouJiZG/v7/eeOMNnT9/Pk/L/POf/9SPP/6ol19+WefOndOgQYMUHh6ugwcP5nm70uX3XZLLna2VMjIysm3PaWKYXfv1nLRu2LBBbdu2la+vr6ZPn67ly5crKSlJjz/+uMN2/fz8tH79eq1evVrdunXTjz/+qE6dOqlVq1Y5vkYrZf3MXX3WgWvlTs1w5dZbb72u+6vU1FQ9+OCDOnXqlFasWJHjJEOSTp06ladaUa5cuWzrRFJSksaNG5fnsT366KM6deqUpk6dmqf+BbkPclUrrtcfoTmttyDqhHR9a8WECRMUFxene++9Vx999JFWrlyppKQkhYeHO0wiatWqpZ07d2r+/Plq2rSpPvnkEzVt2tTpemqF5eTJkypZsqTDN/lAQXKnRmzcuFGvvPKK/dpCOWFewbwiC/MKa9zM8wpCqSLA09NT8fHxOnz4sN59912n5wcOHChJevvtt1W+fHm99tprWrVqlebPn+/Qr2bNmpIu3y3jenjxxRc1Z84cvfXWW+rSpUuufffu3Wv/FjQnWRdgLVeunKKjo50eV34z4eqP9X/84x9asmSJvvnmG3Xs2FGXLl3K02uqW7euRo4cqfXr12vDhg06dOiQEhIS8rRslipVqsjPz8/pfc86LSTrrk5X2rlzZ66njVSvXl2ZmZn69ddfc912UFCQ0x0p0tPT9eeff+Zx9PmX0+tLT0/X3r17c319n3zyiXx9fbVy5Uo9+eSTevDBB3P8ps7Dw0P333+/Jk+erF9//VWvvfaavvzyS7cOw85p/NkdcejOUYh79+6Vh4eH7rjjjmsaC+AOVzXDlZo1a163OnH+/Hm1adNGu3bt0tKlS3P9VvbQoUNKT0/PU604fvy4mjRpkm2tqFevnr2vq1rx7LPPaty4cZo4cWKOp4lcraD2QTnV6KpVqyozM9P+LX+WlJQUnTp1ymWt2Llzpy5evJhjn6zTAa6uFa6+dS4oVatW1eHDh50mtjt27LA/n5NFixapZcuWmjVrljp37qzWrVsrOjo62zsx+fv7q1OnTpozZ47279+v2NhYvfbaa3meUOY0din7uuBurXD1OQcKSm414uTJk+rcubNKlSqlefPm5XqUJfMK5hUS8wp3xs+8Iv8IpYqIFi1aqFGjRpoyZYrDH1CLFy/W559/rnHjxtkPhXzmmWcUERGhuLg4paWl2ftGRUVJunzOcX6dPXtWO3bscDqXddKkSXrzzTf18ssv67nnnst1HampqdqzZ48aN26ca7+YmBgFBARowoQJ2f5BffToUfu//f39JTn/UX2l6OhozZ8/XytWrFC3bt1yPRQzLS3NqcDUrVtXHh4eeboF95VKlCihhg0bOr3vDRs2VLly5ZSQkOCwzi+++ELbt2/P8Q4ektSuXTt5eHho3LhxTq/jysS/evXqWr9+vcPzM2bMsCTtj46Olre3t95++22HMc2aNUupqam5vj5PT0/ZbDaHce7bt09Llixx6HfixAmnZbPO1Xb353S1mJgYbdy4UT/++KO97dSpU3m+xbl0+W5a4eHhbt1VBSgIOdWMvIiKitLJkyddXt8hN8eOHdOOHTscrp2RkZGhTp06aePGjVq4cKG9JuVky5YtkuSyVjz22GPKyMjQ+PHjnZ67dOmSQ13w9/d3eevoV155RUOGDNHw4cP13nvv5dq3IPdBERER8vb2dqoVDz30kCRpypQpDu2TJ0+WpFz3pe3bt9exY8eyDSez9stVq1aVp6enU62YPn26W+PPr4ceekgZGRlOY3zrrbdks9n04IMP5risp6en07frCxcudLr9edY1WLJ4e3urdu3aMsbkGti5UqFCBdWpU0eJiYk6c+aMvX3Dhg366aef8ryerVu3uvycAwUppxrx5JNPav/+/Zo1a5bLa+oxr2BeITGvyCvmFdem4C5CgGv24osvqmPHjpo7d66efvppnT59WoMGDVKDBg0cLhDq4eGhhIQERUZGasSIEXrnnXckSbfddpvq1Kmj1atX68knn3RY9/r16+07maNHj+rMmTN69dVXJUn33nuv7r33XknSpk2b1LJlS40ePVpjxoyRdDkYGzp0qGrUqKFatWrpo48+clh3q1atHG67vXr1ahlj9Mgjj+T6egMCAvTee++pW7duuvvuu9W5c2eVLVtW+/fv17Jly9SkSRP7H7FZtw4fNGiQYmJi5Onpqc6dOzuts127dpozZ466d++ugIAAvf/++9lu+8svv9TAgQPVsWNH3XHHHbp06ZISExPl6emp9u3b5zru7DzyyCMaMWKEwy08S5Qooddff129evVS8+bN1aVLF/utW8PCwnK9re3tt9+uESNGaPz48WrWrJkeffRR+fj4aPPmzapQoYLi4+MlXb4Y7dNPP6327durVatW+uGHH7Ry5UpLDvssW7ashg8frrFjx+qBBx5Q27ZttXPnTk2fPl333HOPnnjiiRyXjY2N1eTJk/XAAw/o8ccf15EjRzRt2jTdfvvtDjvzcePGaf369YqNjVXVqlV15MgRTZ8+XZUqVVLTpk2vafxDhw7VRx99pOjoaA0ePFj+/v6aMWOGKlasqOPHj7v8Fu3ixYv66quv9Mwzz1zTOID8urpm5FVsbKy8vLy0evVqPfXUUw7PJSYm6o8//rCHTevXr7fXim7dutknMe+++67Gjh2rtWvX2r99fuGFF/T555+rTZs2OnHihFOtuHqfkJSUpCpVqqhBgwa5jrd58+bq16+f4uPjtW3bNrVu3VolSpTQb7/9poULF2rq1Knq0KGDpMu14r333tOrr76q22+/XeXKlcv2lJBJkyYpNTVVAwYM0C233JLj/qog90G+vr5q3bq1Vq9e7XDKTL169dSjRw/NmDFDp06dUvPmzbVp0yZ9+OGHateunVq2bJnjOrt3765//etfiouL06ZNm9SsWTOdOXNGq1ev1jPPPKNHHnlEgYGB6tixo9555x3ZbDZVr15dS5cudev6KteiTZs2atmypUaMGKF9+/apXr16WrVqlT777DMNHjzYfnRDdh5++GGNGzdOvXr1UuPGjfXTTz/p448/1m233ebQr3Xr1goNDVWTJk0UEhKi7du3691331VsbKzTtazcNWHCBD3yyCNq1qyZnnzySZ08eVJTp05VeHi4Q1CVky1btujEiRMu/yYCCtrVNSIhIUFLlizRXXfdpbNnzzrto7Nk/V3PvIJ5BfOKvGNecY2suckfslx5W+qrZWRkmOrVq5vq1aubS5cumeeee854eHiYTZs2ZbuugQMHGg8PD/Pdd9/Z2yZPnmxKlSrldFvMrFtZZve48tafWbc4vbItt2WVzW2mO3XqZJo2bZrn92Tt2rUmJibGBAYGGl9fX1O9enXTs2dPh9d16dIl8+yzz5qyZcsam81mvy3nlbduvdL06dONJDNkyBCH15U11t9//908+eSTpnr16sbX19eUKVPGtGzZ0qxevdphPXm5dasxl2+r6+XlZRITE52eW7BggWnQoIHx8fExZcqUMV27djUHDx506JPdrUaNuXy77wYNGtjf6+bNm5ukpCT78xkZGWbYsGEmODjYlCxZ0sTExJjdu3fneOvWqz93Wdu9+taoPXr0MP7+/i5ftzGXb9Vas2ZNU6JECRMSEmL69+9vTp486bS+q2/dOmvWLFOjRg3j4+NjatasaebMmeP0PqxZs8Y88sgjpkKFCsbb29tUqFDBdOnSxezatcveJ7+3bjXm8i18mzVrZnx8fEzFihXN+PHjzdtvv20kmeTkZHu/7G7d+sUXXxhJ5rfffsvT+wTkhzs1I0tO+8UrtW3b1tx///1O7c2bN8/Tvj7rd+zKttyWvfr3MSMjw5QvX96MHDkyz+/FjBkzTEREhPHz8zO33HKLqVu3rhk6dKg5fPiwvU9ycrKJjY01t9xyi32faUz272NGRobp0qWL8fLyMkuWLHF4XVnyuw/KyaeffmpsNpvZv3+/Q/vFixfN2LFjTbVq1UyJEiVM5cqVzfDhw8358+cd+mW3Lzp79qwZMWKEqVatmpFkvLy8TIcOHcyePXvsfY4ePWrat29vSpYsaYKCgky/fv3Mzz//7DTunPb9zZs3N+Hh4U7tVatWNbGxsS5f9+nTp83zzz9vKlSoYEqUKGFq1KhhJk2a5HAr8az1XbmfPn/+vHnhhRdM+fLljZ+fn2nSpInZuHGj0/vw/vvvm3vvvdfceuutxsfHx1SvXt28+OKLJjU11d4n6zOQ2225c/pZzp8/39SsWdN4e3ub2rVrm08//dR06NDB1KxZ06Hf1X8/GWPMsGHDTJUqVZxeK1AQ3KkRPXr0yHUfnd2+nnnFZcwrmFcwr7i+bMZc51vwwFKpqam67bbb9MYbbzjcjtMqycnJqlatmubPn3/TfSvYu3dv7dq1Sxs2bCjwde/bt0+tWrXSL7/8Im9v7wJfP/72/PPPKyEhQX/99VeOF3CULn97ZrPZtHjxYgtHBxSMDRs2qEWLFtqxY4dq1Khh+faXLFmixx9/XHv27FH58uUt335hycjIUO3atfXYY49lezritfroo4+0fPlyt04XQP40aNBAwcHBSkpKyrHPhQsXFBYWppdeesnlKUpAUcS8ovAwr7gxMK/IG64pdYMJDAzU0KFDNWnSpAK5vaW7pkyZorp16950hUOSRo8erc2bNxfIbaivFhYWplKlSum///1vga/7Znbu3DmH/x8/flyJiYlq2rRproVj+/btWrp06XWZVAJWaNasmVq3bq033nijULb/+uuva+DAgTdVICVdvu7FuHHjNG3atHzdOdGVNm3aaNGiRdd8bQz87eLFi07Xilm3bp22bdvm8lbxc+bMUYkSJdw6vRYoSphXFB7mFcUP84r840gpoIgbM2aMgoOD9dJLL2nevHlq27ZtYQ/phlG/fn21aNFCtWrVUkpKimbNmqXDhw9rzZo19ushAEBRt337dq1atUqHDx/WG2+8oVOnTt2UF0q9Hvbt26fo6Gg98cQTqlChgnbs2KGEhAQFBgbq559/tt++HQCKA+YV1w/zivzjQudAEfevf/1Lhw8fVsuWLRUTE1PYw7mhPPTQQ1q0aJFmzJghm82mu+++W7NmzaJwAChWzp8/r1dffVXnz5/Xyy+/TCBVgIKCghQREaGZM2fq6NGj8vf3V2xsrCZOnEggBaDYYV5x/TCvyD+3j5Rav369Jk2apC1btujPP//U4sWL1a5du1yXWbduneLi4vTLL7+ocuXKGjlypHr27HkNwwYAFGXUCgCAK9QKAIDb15Q6c+aM6tWrp2nTpuWp/969exUbG6uWLVtq27ZtGjx4sPr06aOVK1e6PVgAQPFArQAAuEKtAABc0zWlsq4Qn9s3GsOGDdOyZcv0888/29s6d+6sU6dOacWKFfndNACgmKBWAABcoVYAwM3pul9TauPGjYqOjnZoi4mJ0eDBg3Nc5sKFCw53jsnMzNSJEyd06623ymazXa+hAsBNzxij06dPq0KFCvLwsO4GrdQKACg+qBUAAFfyWiuueyiVnJyskJAQh7aQkBClpaXp3Llz8vPzc1omPj5eY8eOvd5DAwDk4MCBA6pUqZJl26NWAEDxQ60AALjiqlYUybvvDR8+XHFxcfb/p6amqkqVKjpw4IACAgIKcWQAcGNLS0tT5cqVdcsttxT2UFyiVgBA4aBWAABcyWutuO6hVGhoqFJSUhzaUlJSFBAQkO23GZLk4+MjHx8fp/aAgACKBwBYwOpTGqgVAFD8UCsAAK64qhXX/STwqKgorVmzxqEtKSlJUVFR13vTAIBigloBAHCFWgEANx63Q6m//vpL27Zt07Zt2yRdvjXrtm3btH//fkmXD5Ht3r27vf/TTz+t33//XUOHDtWOHTs0ffp0/fvf/9bzzz9fMK8AAFDkUCsAAK5QKwAAbodS3333nRo0aKAGDRpIkuLi4tSgQQONGjVKkvTnn3/aC4kkVatWTcuWLVNSUpLq1aunf/7zn5o5c6ZiYmIK6CUAAIoaagUAwBVqBQDAZowxhT0IV9LS0hQYGKjU1FTO/QaA66g472+L89gBoDgpzvvb4jx2AChO8rq/ve7XlAIAAAAAAACuRigFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALBcvkKpadOmKSwsTL6+voqMjNSmTZty7T9lyhTdeeed8vPzU+XKlfX888/r/Pnz+RowAKB4oFYAAFyhVgDAzc3tUGrBggWKi4vT6NGjtXXrVtWrV08xMTE6cuRItv3nzZunl156SaNHj9b27ds1a9YsLViwQC+//PI1Dx4AUDRRKwAArlArAABuh1KTJ09W37591atXL9WuXVsJCQkqWbKkZs+enW3/b775Rk2aNNHjjz+usLAwtW7dWl26dHH5LQgAoPiiVgAAXKFWAADcCqXS09O1ZcsWRUdH/70CDw9FR0dr48aN2S7TuHFjbdmyxV4sfv/9dy1fvlwPPfRQjtu5cOGC0tLSHB4AgOKBWgEAcIVaAQCQJC93Oh87dkwZGRkKCQlxaA8JCdGOHTuyXebxxx/XsWPH1LRpUxljdOnSJT399NO5HmYbHx+vsWPHujM0AEARQa0AALhCrQAASBbcfW/dunWaMGGCpk+frq1bt+rTTz/VsmXLNH78+ByXGT58uFJTU+2PAwcOXO9hAgAKEbUCAOAKtQIAbjxuHSkVHBwsT09PpaSkOLSnpKQoNDQ022VeeeUVdevWTX369JEk1a1bV2fOnNFTTz2lESNGyMPDORfz8fGRj4+PO0MDABQR1AoAgCvUCgCA5OaRUt7e3oqIiNCaNWvsbZmZmVqzZo2ioqKyXebs2bNOBcLT01OSZIxxd7wAgCKOWgEAcIVaAQCQ3DxSSpLi4uLUo0cPNWzYUI0aNdKUKVN05swZ9erVS5LUvXt3VaxYUfHx8ZKkNm3aaPLkyWrQoIEiIyO1e/duvfLKK2rTpo29iAAAbizUCgCAK9QKAIDboVSnTp109OhRjRo1SsnJyapfv75WrFhhv0jh/v37Hb7BGDlypGw2m0aOHKlDhw6pbNmyatOmjV577bWCexUAgCKFWgEAcIVaAQCwmWJwrGtaWpoCAwOVmpqqgICAwh4OANywivP+tjiPHQCKk+K8vy3OYweA4iSv+9vrfvc9AAAAAAAA4GqEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALCcV2EPwCr3vL+7sIeAYmRzv9sLewgACgG1Au6gVgAAAFwbjpQCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWy1coNW3aNIWFhcnX11eRkZHatGlTrv1PnTqlAQMGqHz58vLx8dEdd9yh5cuX52vAAIDigVoBAHCFWgEANzcvdxdYsGCB4uLilJCQoMjISE2ZMkUxMTHauXOnypUr59Q/PT1drVq1Urly5bRo0SJVrFhRf/zxh0qXLl0Q4wcAFEHUCgCAK9QKAIDbodTkyZPVt29f9erVS5KUkJCgZcuWafbs2XrppZec+s+ePVsnTpzQN998oxIlSkiSwsLCrm3UAIAijVoBAHCFWgEAcOv0vfT0dG3ZskXR0dF/r8DDQ9HR0dq4cWO2y3z++eeKiorSgAEDFBISojp16mjChAnKyMi4tpEDAIokagUAwBVqBQBAcvNIqWPHjikjI0MhISEO7SEhIdqxY0e2y/z+++/68ssv1bVrVy1fvly7d+/WM888o4sXL2r06NHZLnPhwgVduHDB/v+0tDR3hgkAKETUCgCAK9QKAIBkwd33MjMzVa5cOc2YMUMRERHq1KmTRowYoYSEhByXiY+PV2BgoP1RuXLl6z1MAEAholYAAFyhVgDAjcetUCo4OFienp5KSUlxaE9JSVFoaGi2y5QvX1533HGHPD097W21atVScnKy0tPTs11m+PDhSk1NtT8OHDjgzjABAIWIWgEAcIVaAQCQ3AylvL29FRERoTVr1tjbMjMztWbNGkVFRWW7TJMmTbR7925lZmba23bt2qXy5cvL29s722V8fHwUEBDg8AAAFA/UCgCAK9QKAICUj9P34uLi9MEHH+jDDz/U9u3b1b9/f505c8Z+14zu3btr+PDh9v79+/fXiRMn9Nxzz2nXrl1atmyZJkyYoAEDBhTcqwAAFCnUCgCAK9QKAIBbFzqXpE6dOuno0aMaNWqUkpOTVb9+fa1YscJ+kcL9+/fLw+PvrKty5cpauXKlnn/+ed11112qWLGinnvuOQ0bNqzgXgUAoEihVgAAXKFWAABsxhhT2INwJS0tTYGBgUpNTc33Ibf3vL+7gEeFG9nmfrcX9hCAQlEQ+9vCQq2A1agVuFnd7LUCAOBaXve31/3uewAAAAAAAMDVCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlvAp7AAAAAABQXNzz/u7CHgKKkc39bi/sIdglt2lW2ENAMRP6nw3XfRscKQUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcvkKpaZNm6awsDD5+voqMjJSmzZtytNy8+fPl81mU7t27fKzWQBAMUKtAAC4Qq0AgJub26HUggULFBcXp9GjR2vr1q2qV6+eYmJidOTIkVyX27dvn4YMGaJmzZrle7AAgOKBWgEAcIVaAQBwO5SaPHmy+vbtq169eql27dpKSEhQyZIlNXv27ByXycjIUNeuXTV27Fjddttt1zRgAEDRR60AALhCrQAAuBVKpaena8uWLYqOjv57BR4eio6O1saNG3Ncbty4cSpXrpx69+6dp+1cuHBBaWlpDg8AQPFArQAAuEKtAABIboZSx44dU0ZGhkJCQhzaQ0JClJycnO0y//3vfzVr1ix98MEHed5OfHy8AgMD7Y/KlSu7M0wAQCGiVgAAXKFWAACk63z3vdOnT6tbt2764IMPFBwcnOflhg8frtTUVPvjwIED13GUAIDCRK0AALhCrQCAG5OXO52Dg4Pl6emplJQUh/aUlBSFhoY69d+zZ4/27dunNm3a2NsyMzMvb9jLSzt37lT16tWdlvPx8ZGPj487QwMAFBHUCgCAK9QKAIDk5pFS3t7eioiI0Jo1a+xtmZmZWrNmjaKiopz616xZUz/99JO2bdtmf7Rt21YtW7bUtm3bOHwWAG5A1AoAgCvUCgCA5OaRUpIUFxenHj16qGHDhmrUqJGmTJmiM2fOqFevXpKk7t27q2LFioqPj5evr6/q1KnjsHzp0qUlyakdAHDjoFYAAFyhVgAA3A6lOnXqpKNHj2rUqFFKTk5W/fr1tWLFCvtFCvfv3y8Pj+t6qSoAQBFHrQAAuEKtAADYjDGmsAfhSlpamgIDA5WamqqAgIB8reOe93cX8KhwI9vc7/bCHgJQKApif1tYqBWwGrUCNytqBbUCeVeUakVym2aFPQQUM6H/2ZDvZfO6v+WrBwAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDmvwh4AgNwlt2lW2ENAMRP6nw2FPQQAFqNWwF3UCgBAUcCRUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAy+UrlJo2bZrCwsLk6+uryMhIbdq0Kce+H3zwgZo1a6agoCAFBQUpOjo61/4AgBsDtQIA4Aq1AgBubm6HUgsWLFBcXJxGjx6trVu3ql69eoqJidGRI0ey7b9u3Tp16dJFa9eu1caNG1W5cmW1bt1ahw4duubBAwCKJmoFAMAVagUAwO1QavLkyerbt6969eql2rVrKyEhQSVLltTs2bOz7f/xxx/rmWeeUf369VWzZk3NnDlTmZmZWrNmzTUPHgBQNFErAACuUCsAAG6FUunp6dqyZYuio6P/XoGHh6Kjo7Vx48Y8rePs2bO6ePGiypQpk2OfCxcuKC0tzeEBACgeqBUAAFeoFQAAyc1Q6tixY8rIyFBISIhDe0hIiJKTk/O0jmHDhqlChQoOBehq8fHxCgwMtD8qV67szjABAIWIWgEAcIVaAQCQLL773sSJEzV//nwtXrxYvr6+OfYbPny4UlNT7Y8DBw5YOEoAQGGiVgAAXKFWAMCNwcudzsHBwfL09FRKSopDe0pKikJDQ3Nd9s0339TEiRO1evVq3XXXXbn29fHxkY+PjztDAwAUEdQKAIAr1AoAgOTmkVLe3t6KiIhwuJhg1sUFo6KiclzujTfe0Pjx47VixQo1bNgw/6MFABR51AoAgCvUCgCA5OaRUpIUFxenHj16qGHDhmrUqJGmTJmiM2fOqFevXpKk7t27q2LFioqPj5ckvf766xo1apTmzZunsLAw+znipUqVUqlSpQrwpQAAigpqBQDAFWoFAMDtUKpTp046evSoRo0apeTkZNWvX18rVqywX6Rw//798vD4+wCs9957T+np6erQoYPDekaPHq0xY8Zc2+gBAEUStQIA4Aq1AgDgdiglSQMHDtTAgQOzfW7dunUO/9+3b19+NgEAKOaoFQAAV6gVAHBzs/TuewAAAAAAAIBEKAUAAAAAAIBCQCgFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAy+UrlJo2bZrCwsLk6+uryMhIbdq0Kdf+CxcuVM2aNeXr66u6detq+fLl+RosAKD4oFYAAFyhVgDAzc3tUGrBggWKi4vT6NGjtXXrVtWrV08xMTE6cuRItv2/+eYbdenSRb1799b333+vdu3aqV27dvr555+vefAAgKKJWgEAcIVaAQBwO5SaPHmy+vbtq169eql27dpKSEhQyZIlNXv27Gz7T506VQ888IBefPFF1apVS+PHj9fdd9+td99995oHDwAomqgVAABXqBUAALdCqfT0dG3ZskXR0dF/r8DDQ9HR0dq4cWO2y2zcuNGhvyTFxMTk2B8AULxRKwAArlArAACS5OVO52PHjikjI0MhISEO7SEhIdqxY0e2yyQnJ2fbPzk5OcftXLhwQRcuXLD/PzU1VZKUlpbmznAdZJw7ne9lcfO5ls9aQTt98VJhDwHFTMlr+PxmffaNMfleB7UCNwtqBYozagW1AtagVqA4s6JWuBVKWSU+Pl5jx451aq9cuXIhjAY3o8DnC3sEwDUIDLzmVZw+fVqBBbCe64lagcJGrUCxRq0ohNHgZkStQLFmQa1wK5QKDg6Wp6enUlJSHNpTUlIUGhqa7TKhoaFu9Zek4cOHKy4uzv7/zMxMnThxQrfeeqtsNps7Q0Yu0tLSVLlyZR04cEABAQGFPRzALXx+rw9jjE6fPq0KFSrkex3UihsLv2sozvj8Xh/UClyN3zUUZ3x+r4+81gq3Qilvb29FRERozZo1ateunaTLO/Y1a9Zo4MCB2S4TFRWlNWvWaPDgwfa2pKQkRUVF5bgdHx8f+fj4OLSVLl3anaHCDQEBAfzyodji81vwrvVbb2rFjYnfNRRnfH4LHrUC2eF3DcUZn9+Cl5da4fbpe3FxcerRo4caNmyoRo0aacqUKTpz5ox69eolSerevbsqVqyo+Ph4SdJzzz2n5s2b65///KdiY2M1f/58fffdd5oxY4a7mwYAFBPUCgCAK9QKAIDboVSnTp109OhRjRo1SsnJyapfv75WrFhhv+jg/v375eHx9039GjdurHnz5mnkyJF6+eWXVaNGDS1ZskR16tQpuFcBAChSqBUAAFeoFQAAm7mW22agWLtw4YLi4+M1fPhwp8OagaKOzy9gDX7XUJzx+QWswe8aijM+v4WLUAoAAAAAAACW83DdBQAAAAAAAChYhFIAAAAAAACwHKEUAAAAAAAALEcodQNat26dwsLCCnsYQL7w+QWswe8aijM+v4A1+F1Dccbnt3gglLoJnDhxQl27dlVAQIBKly6t3r1766+//irsYQF58tprr6lx48YqWbKkSpcuXdjDAW5Y1AoUZ9QKwBrUChRn1IqiiVDqJtC1a1f98ssvSkpK0tKlS7V+/Xo99dRT9ufPnz+vo0ePFuIIgZylp6erY8eO6t+/f4599u/fb+GIgBsTtQLFGbUCsAa1AsUZtaJoIpS6wW3fvl0rVqzQzJkzFRkZqaZNm+qdd97R/PnzdfjwYUlSSkqKKlasqHbt2mnx4sW6ePFiIY8a+NvYsWP1/PPPq27dujn2qVatmqKjo5WYmKizZ89aODrgxkCtQHFHrQCuP2oFijtqRdFEKHWD27hxo0qXLq2GDRva26Kjo+Xh4aFvv/1WklS1alVt3LhRVatWVb9+/VS+fHkNGjRIW7ZsKaxhA2759ddf1ahRI40cOVIhISF68skn9dVXX8kYU9hDA4oFagVuBtQK4NpQK3AzoFZYj1DqBpecnKxy5co5tHl5ealMmTJKTk62t0VERGjq1Kk6fPiw5syZoz///FNNmjRR3bp19eabbyolJcXqoQN5duedd2rChAnat2+fPv/8cxlj1KZNG1WvXl1jxozR3r17C3uIQJFGrcDNgFoBXBtqBW4G1ArrEUrBgZeXl9q0aaOFCxdq7969Cg0N1Ysvvqj4+PjCHhrgks1mU8uWLTVnzhwdPHhQUVFR9sN0ARQcagWKM2oFYA1qBYozaoV1vAp7ALi+QkNDdeTIEYe2S5cu6cSJEwoNDXXqb4zRhg0blJiYqIULFyooKEijRo1S7969rRoycE22bt2qf/3rX/p//+//yWazKS4uTn369CnsYQFFGrUCNxtqBeA+agVuNtQKaxBK3eCioqJ06tQpbdmyRREREZKkL7/8UpmZmYqMjLT327VrlxITE/XRRx/p2LFj6tChg5YsWaLmzZvLZrMV1vCBPDl48KA++ugjJSYmas+ePWrTpo1mzZqlBx54QF5e7OYAV6gVuBlQK4BrQ63AzYBaYT3e1RtcrVq19MADD6hv375KSEjQxYsXNXDgQHXu3FkVKlSQdPm2l7Vq1VKLFi00duxYtW/fXv7+/oU8cuCy/fv368SJE9q/f78yMjK0bds2SdLtt9+uUqVKSbp8Uc2GDRtqwIAB6tKli4KCggpxxEDxQ61AcUetAK4/agWKO2pF0UQodRP4+OOPNXDgQN1///3y8PBQ+/bt9fbbb9ufDw4O1t69e1WlSpVCHCWQvVGjRunDDz+0/79BgwaSpLVr16pFixaSpF9++UU1a9YsjOEBNwxqBYozagVgDWoFijNqRdFEKHUTKFOmjObNm5fj8yVLlqRwoMiaO3eu5s6dm2sfCgdw7agVKM6oFYA1qBUozqgVRRN33wMAAAAAAIDlCKUAAAAAAABgOUKpG1BYWJgGDx5c2MMA8oXPL2ANftdQnPH5BazB7xqKMz6/xYPNGGMKexAAAAAAAAC4uXCkFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsNz/B01nRi1xLOanAAAAAElFTkSuQmCC\n"
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Not: RZ tek başına |0> üzerinde ölçüm olasılığını değiştirmez; faz bilgisidir.\n",
      "Feature map'lerde RZ + entanglement ile anlamlı hale gelir.\n"
     ]
    }
   ],
   "source": "# Aynı veriyi RX / RZ ile kodlama farkı\ndef angle_encode_axis(x_list, axis=\"Y\"):\n    n = len(x_list)\n    qc = QuantumCircuit(n, name=f\"angle_R{axis}\")\n    for i, x in enumerate(x_list):\n        if axis == \"X\":\n            qc.rx(float(x), i)\n        elif axis == \"Y\":\n            qc.ry(float(x), i)\n        else:\n            qc.rz(float(x), i)\n            # RZ |0> faz çevirir; ölçümde fark görünmez → önce H\n            if i == 0:\n                pass\n    return qc\n\nfig, axes = plt.subplots(1, 3, figsize=(12, 3.5))\nfor ax, axis in zip(axes, [\"X\", \"Y\", \"Z\"]):\n    qc = QuantumCircuit(1)\n    if axis == \"X\":\n        qc.rx(1.2, 0)\n    elif axis == \"Y\":\n        qc.ry(1.2, 0)\n    else:\n        qc.h(0); qc.rz(1.2, 0)  # fazı görünür kılmak için\n    sv = Statevector.from_instruction(qc)\n    # basit bar\n    probs = np.abs(sv.data)**2\n    ax.bar([\"|0>\", \"|1>\"], probs, color=[\"#3498db\", \"#e74c3c\"])\n    ax.set_ylim(0, 1)\n    ax.set_title(f\"R{axis}(1.2) etkisi (ölçüm olasılığı)\")\nplt.tight_layout()\nplt.show()\n\nprint(\"Not: RZ tek başına |0> üzerinde ölçüm olasılığını değiştirmez; faz bilgisidir.\")\nprint(\"Feature map'lerde RZ + entanglement ile anlamlı hale gelir.\")\n",
   "id": "angle_axes"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s5"
   },
   "source": "## 5. Dense Angle Encoding\n\n**Fikir:** Bir qubit’e birden fazla özellik sıkıştır.\n\nÖrnek (2 özellik → 1 qubit):\n\n$$\nR_z(x_1)\\, R_y(x_2)\\, |0\\rangle\n$$\n\nveya\n\n$$\nR_y(x_1)\\, R_z(x_2)\\, R_y(x_1) \\ldots\n$$\n\n**Artı:** Az qubit.  \n**Eksi:** Bilgi çakışması / daha az ayrıştırılabilirlik; genelde tekrar (reps) gerekir.\n",
   "id": "s5"
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "dense",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655086697,
     "user_tz": -180,
     "elapsed": 700,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "4ecd1e58-3ab2-4490-997e-fa5cc9dc508d"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Dense angle x= [0.6, 1.4] reps=2\n",
      "   ┌─────────┐┌─────────┐┌─────────┐┌─────────┐\n",
      "q: ┤ Ry(0.6) ├┤ Rz(1.4) ├┤ Ry(0.6) ├┤ Rz(1.4) ├\n",
      "   └─────────┘└─────────┘└─────────┘└─────────┘\n",
      "Statevector: [0.0678-0.8994j 0.3303+0.2782j]\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {}
    }
   ],
   "source": "def dense_angle_encode(x, reps=1):\n    \"\"\"x: uzunluk 2 vektör → 1 qubit; veya çiftler halinde.\"\"\"\n    x = list(x)\n    if len(x) % 2 == 1:\n        x = x + [0.0]\n    n = len(x) // 2\n    qc = QuantumCircuit(n, name=\"dense_angle\")\n    for r in range(reps):\n        for i in range(n):\n            qc.ry(float(x[2*i]), i)\n            qc.rz(float(x[2*i + 1]), i)\n    return qc\n\nx = [0.6, 1.4]\nqc_d = dense_angle_encode(x, reps=2)\nprint(\"Dense angle x=\", x, \"reps=2\")\nprint(qc_d.draw(output=\"text\"))\nsv = Statevector.from_instruction(qc_d)\nprint(\"Statevector:\", np.round(sv.data, 4))\nplot_bloch_multivector(sv)\nplt.suptitle(\"Dense angle: RY(0.6) RZ(1.4) × 2\")\nplt.show()\n",
   "id": "dense"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s6"
   },
   "source": "## 6. Amplitude Encoding\n\n**Fikir:** Normalize edilmiş klasik vektör $x$ doğrudan durum genlikleri olsun:\n\n$$\n|x\\rangle = \\sum_{i=0}^{N-1} x_i |i\\rangle, \\quad \\|x\\|_2 = 1, \\quad N=2^n\n$$\n\n**Artı:** $2^n$ boyutlu vektör → $n$ qubit (üstel sıkıştırma).  \n**Eksi:** Genel vektörü hazırlamak (state preparation) pahalı olabilir; $O(2^n)$ kapı.\n\nQiskit’te `initialize` veya `StatePreparation` kullanılır.\n",
   "id": "s6"
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "amplitude",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655087144,
     "user_tz": -180,
     "elapsed": 298,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "57ab3837-3d68-4ff4-db1f-41e74b160f36"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Klasik vektör: [0.4, 0.1, 0.3, 0.2]\n",
      "Normalize+pad: [0.7303 0.1826 0.5477 0.3651]\n",
      "          ┌────────────────────────────────────────────────────┐\n",
      "q_0: ─|0>─┤0                                                   ├\n",
      "          │  State Preparation(0.7303,0.18257,0.54772,0.36515) │\n",
      "q_1: ─|0>─┤1                                                   ├\n",
      "          └────────────────────────────────────────────────────┘\n",
      "Elde edilen genlikler: [0.7303+0.j 0.1826+0.j 0.5477+0.j 0.3651+0.j]\n",
      "|genlik|²        : [0.5333 0.0333 0.3    0.1333]\n",
      "Klasik |x_i|²    : [0.5333 0.0333 0.3    0.1333]\n"
     ]
    }
   ],
   "source": "def amplitude_encode(vec):\n    \"\"\"Normalize + initialize.\"\"\"\n    v = np.array(vec, dtype=float)\n    # 2^n uzunluğa pad\n    n = int(np.ceil(np.log2(max(len(v), 1))))\n    size = 2 ** n\n    padded = np.zeros(size)\n    padded[:len(v)] = v\n    norm = np.linalg.norm(padded)\n    if norm < 1e-12:\n        raise ValueError(\"Sıfır vektör kodlanamaz\")\n    padded = padded / norm\n    qc = QuantumCircuit(n, name=\"amplitude\")\n    qc.initialize(padded, range(n))\n    return qc, padded\n\nvec = [0.4, 0.1, 0.3, 0.2]  # 4 boyut → 2 qubit\nqc_amp, padded = amplitude_encode(vec)\nprint(\"Klasik vektör:\", vec)\nprint(\"Normalize+pad:\", np.round(padded, 4))\nprint(qc_amp.decompose().draw(output=\"text\", fold=100))\n\nsv = Statevector.from_instruction(qc_amp)\nprint(\"Elde edilen genlikler:\", np.round(sv.data, 4))\nprint(\"|genlik|²        :\", np.round(np.abs(sv.data)**2, 4))\nprint(\"Klasik |x_i|²    :\", np.round(padded**2, 4))\n",
   "id": "amplitude"
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "amp_vs_angle",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655087397,
     "user_tz": -180,
     "elapsed": 150,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "d54ac187-8fbd-4502-dc7a-c624be39f475"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Angle encoding (2 qubit) state: [0.8799+0.j 0.372 +0.j 0.2722+0.j 0.1151+0.j]\n",
      "Amplitude (1 qubit) state    : [0.8+0.j 0.6+0.j]\n",
      "\n",
      "Fark:\n",
      "- Angle: her özellik ayrı rotasyon; entanglement yoksa ürün durumu\n",
      "- Amplitude: tüm vektör tek global durumda; göreli genlikler bilgi taşır\n",
      "\n"
     ]
    }
   ],
   "source": "# Amplitude vs Angle: aynı 2 özellik\nx2 = [0.8, 0.6]\n# Angle: 2 qubit\nqc_a = angle_encode_ry(x2)\n# Amplitude: normalize [x0, x1, 0, 0] → aslında 2 boyut için 1 qubit yeterli\nv = np.array(x2, dtype=float)\nv = v / np.linalg.norm(v)\nqc_b = QuantumCircuit(1)\nqc_b.initialize(v, [0])\n\nprint(\"Angle encoding (2 qubit) state:\", np.round(Statevector.from_instruction(qc_a).data, 4))\nprint(\"Amplitude (1 qubit) state    :\", np.round(Statevector.from_instruction(qc_b).data, 4))\nprint(\"\"\"\nFark:\n- Angle: her özellik ayrı rotasyon; entanglement yoksa ürün durumu\n- Amplitude: tüm vektör tek global durumda; göreli genlikler bilgi taşır\n\"\"\")\n",
   "id": "amp_vs_angle"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s7"
   },
   "source": "## 7. Phase / Hamiltonian Encoding\n\n**Fikir:** Veriyi faz olarak yaz: $e^{i x}$ veya diagonal unitary.\n\nÖrnek:\n\n$$\nP(x)|1\\rangle = e^{i x}|1\\rangle\n$$\n\nveya IQP tarzı: $H^{\\otimes n}$ → diagonal fazlar → $H^{\\otimes n}$\n\nÖzellikler arasındaki etkileşim $Z_i Z_j$ terimleriyle kodlanabilir (ZZFeatureMap’in özü).\n",
   "id": "s7"
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "phase_zz",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655087697,
     "user_tz": -180,
     "elapsed": 158,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "fef6144f-70df-42d7-92c3-bd7d57498bc7"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "     ┌───┐┌────────┐\n",
      "q_0: ┤ H ├┤ P(0.3) ├\n",
      "     ├───┤├────────┤\n",
      "q_1: ┤ H ├┤ P(1.1) ├\n",
      "     └───┘└────────┘\n",
      "Statevector: [0.5   +0.j     0.4777+0.1478j 0.2268+0.4456j 0.085 +0.4927j]\n",
      "\n",
      "ZZ-style embedding:\n",
      "     ┌───┐┌─────────┐                      \n",
      "q_0: ┤ H ├┤ Rz(0.8) ├──■────────────────■──\n",
      "     ├───┤├─────────┤┌─┴─┐┌──────────┐┌─┴─┐\n",
      "q_1: ┤ H ├┤ Rz(1.8) ├┤ X ├┤ Rz(0.72) ├┤ X ├\n",
      "     └───┘└─────────┘└───┘└──────────┘└───┘\n"
     ]
    }
   ],
   "source": "def phase_encode(x_list):\n    n = len(x_list)\n    qc = QuantumCircuit(n, name=\"phase\")\n    qc.h(range(n))  # süperpozisyon\n    for i, x in enumerate(x_list):\n        qc.p(float(x), i)  # phase gate\n    return qc\n\nx = [0.3, 1.1]\nqc_ph = phase_encode(x)\nprint(qc_ph.draw(output=\"text\"))\nsv = Statevector.from_instruction(qc_ph)\nprint(\"Statevector:\", np.round(sv.data, 4))\n\n# ZZ etkileşimli basit embedding\ndef zz_embed(x_list):\n    n = len(x_list)\n    qc = QuantumCircuit(n, name=\"zz_embed\")\n    for i, x in enumerate(x_list):\n        qc.h(i)\n        qc.rz(2 * float(x), i)\n    for i in range(n - 1):\n        qc.cx(i, i + 1)\n        qc.rz(2 * float(x_list[i]) * float(x_list[i+1]), i + 1)\n        qc.cx(i, i + 1)\n    return qc\n\nqc_zz = zz_embed([0.4, 0.9])\nprint(\"\\nZZ-style embedding:\")\nprint(qc_zz.draw(output=\"text\"))\n",
   "id": "phase_zz"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s8"
   },
   "source": "## 8. Hazır Feature Map’ler (Qiskit Circuit Library)\n\nQML’de veri kodlama çoğu zaman **Feature Map** sınıfıyla yapılır:\n\n- `ZZFeatureMap` — angle + ZZ entanglement\n- `PauliFeatureMap` — genel Pauli dizileri\n- `ZFeatureMap` — sadece Z rotasyonları\n\nBunlar `qiskit-machine-learning` içinde VQC / Quantum Kernel ile doğrudan kullanılır.\n",
   "id": "s8"
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "feature_maps",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655087946,
     "user_tz": -180,
     "elapsed": 148,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "cfc21c06-e637-4c80-c0a3-4ea42ca23410"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "=== ZZFeatureMap ===\n",
      "     ┌───┐┌───────────┐                                        ┌───┐        ┌───────────┐                   »\n",
      "q_0: ┤ H ├┤ P(2*x[0]) ├──■──────────────────────────────────■──┤ H ├────────┤ P(2*x[0]) ├───────────────────»\n",
      "     ├───┤├───────────┤┌─┴─┐┌────────────────────────────┐┌─┴─┐└───┘        └───────────┘              ┌───┐»\n",
      "q_1: ┤ H ├┤ P(2*x[1]) ├┤ X ├┤ P(2*(π - x[0])*(π - x[1])) ├┤ X ├──■──────────────────────────────────■──┤ H ├»\n",
      "     ├───┤├───────────┤└───┘└────────────────────────────┘└───┘┌─┴─┐┌────────────────────────────┐┌─┴─┐├───┤»\n",
      "q_2: ┤ H ├┤ P(2*x[2]) ├────────────────────────────────────────┤ X ├┤ P(2*(π - x[1])*(π - x[2])) ├┤ X ├┤ H ├»\n",
      "     └───┘└───────────┘                                        └───┘└────────────────────────────┘└───┘└───┘»\n",
      "«                                                                                                  \n",
      "«q_0: ───────────────■──────────────────────────────────■──────────────────────────────────────────\n",
      "«     ┌───────────┐┌─┴─┐┌────────────────────────────┐┌─┴─┐                                        \n",
      "«q_1: ┤ P(2*x[1]) ├┤ X ├┤ P(2*(π - x[0])*(π - x[1])) ├┤ X ├──■──────────────────────────────────■──\n",
      "«     ├───────────┤└───┘└────────────────────────────┘└───┘┌─┴─┐┌────────────────────────────┐┌─┴─┐\n",
      "«q_2: ┤ P(2*x[2]) ├────────────────────────────────────────┤ X ├┤ P(2*(π - x[1])*(π - x[2])) ├┤ X ├\n",
      "«     └───────────┘                                        └───┘└────────────────────────────┘└───┘\n",
      "\n",
      "Parametreler: ParameterView([ParameterVectorElement(x[0]), ParameterVectorElement(x[1]), ParameterVectorElement(x[2])])\n",
      "Kodlanmış durum normu: 1.0\n",
      "|genlik|² (ilk 8): [0.0419 0.035  0.0191 0.0411 0.1853 0.1899 0.3384 0.1493]\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/tmp/ipykernel_5533/4110311906.py:3: DeprecationWarning: The class ``qiskit.circuit.library.data_preparation._zz_feature_map.ZZFeatureMap`` is deprecated as of Qiskit 2.1. It will be removed in Qiskit 3.0. Use the zz_feature_map function as a replacement. Note that this will no longer return a BlueprintCircuit, but just a plain QuantumCircuit.\n",
      "  fm_zz = ZZFeatureMap(feature_dimension=3, reps=2, entanglement=\"linear\")\n",
      "/tmp/ipykernel_5533/4110311906.py:4: DeprecationWarning: The class ``qiskit.circuit.library.data_preparation.pauli_feature_map.PauliFeatureMap`` is deprecated as of Qiskit 2.1. It will be removed in Qiskit 3.0. Use the pauli_feature_map function as a replacement. Note that this will no longer return a BlueprintCircuit, but just a plain QuantumCircuit.\n",
      "  fm_pauli = PauliFeatureMap(feature_dimension=3, reps=1, paulis=[\"Z\", \"YY\", \"ZZ\"])\n"
     ]
    }
   ],
   "source": "x = [0.5, 1.0, 1.5]\n\nfm_zz = ZZFeatureMap(feature_dimension=3, reps=2, entanglement=\"linear\")\nfm_pauli = PauliFeatureMap(feature_dimension=3, reps=1, paulis=[\"Z\", \"YY\", \"ZZ\"])\n\nprint(\"=== ZZFeatureMap ===\")\nprint(fm_zz.decompose().draw(output=\"text\", fold=120))\n\nprint(\"\\nParametreler:\", fm_zz.parameters)\n# Veriyi bağla (bind / assign)\nbound = fm_zz.assign_parameters(x)\nsv = Statevector.from_instruction(bound)\nprint(\"Kodlanmış durum normu:\", np.round(np.linalg.norm(sv.data), 4))\nprint(\"|genlik|² (ilk 8):\", np.round(np.abs(sv.data)**2, 4))\n",
   "id": "feature_maps"
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "fidelity",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655088241,
     "user_tz": -180,
     "elapsed": 252,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "ecb836ef-8a3d-42a3-cb23-2a1f3acc40f3"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Fidelity (benzerlik):\n",
      "  x1 vs x2 (yakın): 0.9990\n",
      "  x1 vs x3 (uzak) : 0.0080\n",
      "Yakın klasik noktalar → yüksek fidelity; quantum kernel bunun üzerine kurulur.\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/tmp/ipykernel_5533/3370180674.py:3: DeprecationWarning: The class ``qiskit.circuit.library.data_preparation._zz_feature_map.ZZFeatureMap`` is deprecated as of Qiskit 2.1. It will be removed in Qiskit 3.0. Use the zz_feature_map function as a replacement. Note that this will no longer return a BlueprintCircuit, but just a plain QuantumCircuit.\n",
      "  fm = ZZFeatureMap(feature_dimension=len(x), reps=reps, entanglement=\"linear\")\n"
     ]
    }
   ],
   "source": "# Farklı x değerleri → farklı durumlar (kernel için temel)\ndef state_from_x(x, reps=1):\n    fm = ZZFeatureMap(feature_dimension=len(x), reps=reps, entanglement=\"linear\")\n    return Statevector.from_instruction(fm.assign_parameters(x))\n\nx1 = [0.2, 0.4]\nx2 = [0.2, 0.41]   # çok yakın\nx3 = [1.5, 2.0]     # uzak\n\ns1, s2, s3 = state_from_x(x1), state_from_x(x2), state_from_x(x3)\n\ndef fidelity(a, b):\n    return float(np.abs(np.vdot(a.data, b.data))**2)\n\nprint(\"Fidelity (benzerlik):\")\nprint(f\"  x1 vs x2 (yakın): {fidelity(s1, s2):.4f}\")\nprint(f\"  x1 vs x3 (uzak) : {fidelity(s1, s3):.4f}\")\nprint(\"Yakın klasik noktalar → yüksek fidelity; quantum kernel bunun üzerine kurulur.\")\n",
   "id": "fidelity"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s9"
   },
   "source": "## 9. Karşılaştırma ve Seçim Rehberi\n",
   "id": "s9"
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "table",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 340
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655088647,
     "user_tz": -180,
     "elapsed": 410,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "76f8fb50-c426-40d1-d323-7c67ec8a2e2f"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "=== Encoding seçim tablosu ===\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "          Yöntem Qubit ihtiyacı            Süreklilik           Derinlik  \\\n",
       "0          Basis         O(bit)  Kuantizasyon gerekir              Düşük   \n",
       "1  Angle (RY/RX)     O(özellik)                 Doğal         Düşük–orta   \n",
       "2    Dense angle   O(özellik/2)                 Doğal               Orta   \n",
       "3      Amplitude   O(log boyut)      Normalize vektör  Yüksek (hazırlık)   \n",
       "4  ZZ / Pauli FM     O(özellik)                 Doğal        Orta (reps)   \n",
       "\n",
       "                      Tipik kullanım  \n",
       "0              Ayrık veri, aritmetik  \n",
       "1                     VQC, genel QML  \n",
       "2                   Az qubit bütçesi  \n",
       "3  Teorik hızlanma, QSVM varyantları  \n",
       "4                Quantum kernel, VQC  "
      ],
      "text/html": [
       "\n",
       "  <div id=\"df-8ce438b1-32bd-4ffa-83f1-345712ab95cd\" class=\"colab-df-container\">\n",
       "    <div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Yöntem</th>\n",
       "      <th>Qubit ihtiyacı</th>\n",
       "      <th>Süreklilik</th>\n",
       "      <th>Derinlik</th>\n",
       "      <th>Tipik kullanım</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Basis</td>\n",
       "      <td>O(bit)</td>\n",
       "      <td>Kuantizasyon gerekir</td>\n",
       "      <td>Düşük</td>\n",
       "      <td>Ayrık veri, aritmetik</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Angle (RY/RX)</td>\n",
       "      <td>O(özellik)</td>\n",
       "      <td>Doğal</td>\n",
       "      <td>Düşük–orta</td>\n",
       "      <td>VQC, genel QML</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Dense angle</td>\n",
       "      <td>O(özellik/2)</td>\n",
       "      <td>Doğal</td>\n",
       "      <td>Orta</td>\n",
       "      <td>Az qubit bütçesi</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Amplitude</td>\n",
       "      <td>O(log boyut)</td>\n",
       "      <td>Normalize vektör</td>\n",
       "      <td>Yüksek (hazırlık)</td>\n",
       "      <td>Teorik hızlanma, QSVM varyantları</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ZZ / Pauli FM</td>\n",
       "      <td>O(özellik)</td>\n",
       "      <td>Doğal</td>\n",
       "      <td>Orta (reps)</td>\n",
       "      <td>Quantum kernel, VQC</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>\n",
       "    <div class=\"colab-df-buttons\">\n",
       "\n",
       "  <div class=\"colab-df-container\">\n",
       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8ce438b1-32bd-4ffa-83f1-345712ab95cd')\"\n",
       "            title=\"Convert this dataframe to an interactive table.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "\n",
       "  <style>\n",
       "    .colab-df-container {\n",
       "      display:flex;\n",
       "      gap: 12px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert {\n",
       "      background-color: #E8F0FE;\n",
       "      border: none;\n",
       "      border-radius: 50%;\n",
       "      cursor: pointer;\n",
       "      display: none;\n",
       "      fill: #1967D2;\n",
       "      height: 32px;\n",
       "      padding: 0 0 0 0;\n",
       "      width: 32px;\n",
       "    }\n",
       "\n",
       "    .colab-df-convert:hover {\n",
       "      background-color: #E2EBFA;\n",
       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "      fill: #174EA6;\n",
       "    }\n",
       "\n",
       "    .colab-df-buttons div {\n",
       "      margin-bottom: 4px;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert {\n",
       "      background-color: #3B4455;\n",
       "      fill: #D2E3FC;\n",
       "    }\n",
       "\n",
       "    [theme=dark] .colab-df-convert:hover {\n",
       "      background-color: #434B5C;\n",
       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "      fill: #FFFFFF;\n",
       "    }\n",
       "  </style>\n",
       "\n",
       "    <script>\n",
       "      const buttonEl =\n",
       "        document.querySelector('#df-8ce438b1-32bd-4ffa-83f1-345712ab95cd button.colab-df-convert');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      async function convertToInteractive(key) {\n",
       "        const element = document.querySelector('#df-8ce438b1-32bd-4ffa-83f1-345712ab95cd');\n",
       "        const dataTable =\n",
       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
       "                                                    [key], {});\n",
       "        if (!dataTable) return;\n",
       "\n",
       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
       "          + ' to learn more about interactive tables.';\n",
       "        element.innerHTML = '';\n",
       "        dataTable['output_type'] = 'display_data';\n",
       "        await google.colab.output.renderOutput(dataTable, element);\n",
       "        const docLink = document.createElement('div');\n",
       "        docLink.innerHTML = docLinkHtml;\n",
       "        element.appendChild(docLink);\n",
       "      }\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "\n",
       "  <div id=\"id_b810b32c-0de5-427f-8770-bbfeda2916a6\">\n",
       "    <style>\n",
       "      .colab-df-generate {\n",
       "        background-color: #E8F0FE;\n",
       "        border: none;\n",
       "        border-radius: 50%;\n",
       "        cursor: pointer;\n",
       "        display: none;\n",
       "        fill: #1967D2;\n",
       "        height: 32px;\n",
       "        padding: 0 0 0 0;\n",
       "        width: 32px;\n",
       "      }\n",
       "\n",
       "      .colab-df-generate:hover {\n",
       "        background-color: #E2EBFA;\n",
       "        box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
       "        fill: #174EA6;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate {\n",
       "        background-color: #3B4455;\n",
       "        fill: #D2E3FC;\n",
       "      }\n",
       "\n",
       "      [theme=dark] .colab-df-generate:hover {\n",
       "        background-color: #434B5C;\n",
       "        box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
       "        filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
       "        fill: #FFFFFF;\n",
       "      }\n",
       "    </style>\n",
       "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('df')\"\n",
       "            title=\"Generate code using this dataframe.\"\n",
       "            style=\"display:none;\">\n",
       "\n",
       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
       "       width=\"24px\">\n",
       "    <path d=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
       "  </svg>\n",
       "    </button>\n",
       "    <script>\n",
       "      (() => {\n",
       "      const buttonEl =\n",
       "        document.querySelector('#id_b810b32c-0de5-427f-8770-bbfeda2916a6 button.colab-df-generate');\n",
       "      buttonEl.style.display =\n",
       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
       "\n",
       "      buttonEl.onclick = () => {\n",
       "        google.colab.notebook.generateWithVariable('df');\n",
       "      }\n",
       "      })();\n",
       "    </script>\n",
       "  </div>\n",
       "\n",
       "    </div>\n",
       "  </div>\n"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "dataframe",
       "variable_name": "df",
       "summary": "{\n  \"name\": \"df\",\n  \"rows\": 5,\n  \"fields\": [\n    {\n      \"column\": \"Y\\u00f6ntem\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 5,\n        \"samples\": [\n          \"Angle (RY/RX)\",\n          \"ZZ / Pauli FM\",\n          \"Dense angle\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Qubit ihtiyac\\u0131\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 4,\n        \"samples\": [\n          \"O(\\u00f6zellik)\",\n          \"O(log boyut)\",\n          \"O(bit)\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"S\\u00fcreklilik\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"Kuantizasyon gerekir\",\n          \"Do\\u011fal\",\n          \"Normalize vekt\\u00f6r\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Derinlik\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 5,\n        \"samples\": [\n          \"D\\u00fc\\u015f\\u00fck\\u2013orta\",\n          \"Orta (reps)\",\n          \"Orta\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Tipik kullan\\u0131m\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 5,\n        \"samples\": [\n          \"VQC, genel QML\",\n          \"Quantum kernel, VQC\",\n          \"Az qubit b\\u00fct\\u00e7esi\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "Pratik kural:\n",
      "1. Tabular QML, az özellik → Angle veya ZZFeatureMap\n",
      "2. Çok boyutlu normalize vektör + bol kaynak → Amplitude (dikkat: hazırlık maliyeti)\n",
      "3. Tam sayı / kategori → Basis (+ gerekirse one-hot sonra angle)\n",
      "4. Gerçek donanım → sığ (low-depth) angle / ZZ, az reps\n",
      "\n"
     ]
    }
   ],
   "source": "df = pd.DataFrame([\n    {\"Yöntem\": \"Basis\", \"Qubit ihtiyacı\": \"O(bit)\", \"Süreklilik\": \"Kuantizasyon gerekir\",\n     \"Derinlik\": \"Düşük\", \"Tipik kullanım\": \"Ayrık veri, aritmetik\"},\n    {\"Yöntem\": \"Angle (RY/RX)\", \"Qubit ihtiyacı\": \"O(özellik)\", \"Süreklilik\": \"Doğal\",\n     \"Derinlik\": \"Düşük–orta\", \"Tipik kullanım\": \"VQC, genel QML\"},\n    {\"Yöntem\": \"Dense angle\", \"Qubit ihtiyacı\": \"O(özellik/2)\", \"Süreklilik\": \"Doğal\",\n     \"Derinlik\": \"Orta\", \"Tipik kullanım\": \"Az qubit bütçesi\"},\n    {\"Yöntem\": \"Amplitude\", \"Qubit ihtiyacı\": \"O(log boyut)\", \"Süreklilik\": \"Normalize vektör\",\n     \"Derinlik\": \"Yüksek (hazırlık)\", \"Tipik kullanım\": \"Teorik hızlanma, QSVM varyantları\"},\n    {\"Yöntem\": \"ZZ / Pauli FM\", \"Qubit ihtiyacı\": \"O(özellik)\", \"Süreklilik\": \"Doğal\",\n     \"Derinlik\": \"Orta (reps)\", \"Tipik kullanım\": \"Quantum kernel, VQC\"},\n])\nprint(\"=== Encoding seçim tablosu ===\")\ndisplay(df)\n\nprint(\"\"\"\nPratik kural:\n1. Tabular QML, az özellik → Angle veya ZZFeatureMap\n2. Çok boyutlu normalize vektör + bol kaynak → Amplitude (dikkat: hazırlık maliyeti)\n3. Tam sayı / kategori → Basis (+ gerekirse one-hot sonra angle)\n4. Gerçek donanım → sığ (low-depth) angle / ZZ, az reps\n\"\"\")\n",
   "id": "table"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s10"
   },
   "source": "## 10. Mini Uçtan Uca Örnek\n\nİki özellikli sentetik veri → StandardScaler benzeri ölçekleme → Angle + ZZ encoding → ölçüm istatistiği.\n",
   "id": "s10"
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "e2e",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 614
    },
    "executionInfo": {
     "status": "ok",
     "timestamp": 1787655098988,
     "user_tz": -180,
     "elapsed": 10296,
     "user": {
      "displayName": "Joseph Volkan ÖZCAN",
      "userId": "11389530967736397480"
     }
    },
    "outputId": "9e312917-f247-4e7c-cebf-3a7c1a9e6892"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Ölçeklenmiş örnekler (ilk 5):\n",
      "[[0.578 0.078]\n",
      " [0.692 0.668]\n",
      " [0.    0.   ]\n",
      " [0.533 0.294]\n",
      " [0.496 0.134]]\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/tmp/ipykernel_5533/1602332347.py:16: DeprecationWarning: The class ``qiskit.circuit.library.data_preparation._zz_feature_map.ZZFeatureMap`` is deprecated as of Qiskit 2.1. It will be removed in Qiskit 3.0. Use the zz_feature_map function as a replacement. Note that this will no longer return a BlueprintCircuit, but just a plain QuantumCircuit.\n",
      "  fm = ZZFeatureMap(2, reps=1, entanglement=\"linear\")\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "Sınıf 0 ortalama P(|00>): 0.2552734375\n",
      "Sınıf 1 ortalama P(|00>): 0.24775390625\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    }
   ],
   "source": "# Sentetik 2D veri\nrng = np.random.default_rng(42)\nX0 = rng.normal([0.3, 0.3], 0.1, size=(20, 2))\nX1 = rng.normal([1.2, 1.0], 0.15, size=(20, 2))\nX = np.vstack([X0, X1])\ny = np.array([0]*20 + [1]*20)\n\n# [0, π] aralığına ölçekle (angle encoding için uygun)\nX_min, X_max = X.min(axis=0), X.max(axis=0)\nX_scaled = (X - X_min) / (X_max - X_min + 1e-9) * np.pi\n\nprint(\"Ölçeklenmiş örnekler (ilk 5):\")\nprint(np.round(X_scaled[:5], 3))\n\ndef encode_and_measure(x, shots=512):\n    fm = ZZFeatureMap(2, reps=1, entanglement=\"linear\")\n    qc = fm.assign_parameters(x)\n    qc.measure_all()\n    counts = sim.run(transpile(qc, sim), shots=shots).result().get_counts()\n    # |00> oranı basit özellik gibi\n    return counts.get(\"00\", 0) / shots\n\nscores = [encode_and_measure(x) for x in X_scaled]\nprint(\"\\nSınıf 0 ortalama P(|00>):\", np.mean(scores[:20]))\nprint(\"Sınıf 1 ortalama P(|00>):\", np.mean(scores[20:]))\n\nplt.figure(figsize=(6, 4))\nplt.scatter(X_scaled[:20, 0], X_scaled[:20, 1], c=\"#3498db\", label=\"Sınıf 0\", alpha=0.8)\nplt.scatter(X_scaled[20:, 0], X_scaled[20:, 1], c=\"#e74c3c\", label=\"Sınıf 1\", alpha=0.8)\nplt.xlabel(\"x0 (0..π)\"); plt.ylabel(\"x1 (0..π)\")\nplt.title(\"Ölçeklenmiş klasik veri (encoding girdisi)\")\nplt.legend(); plt.grid(True, alpha=0.3); plt.tight_layout(); plt.show()\n",
   "id": "e2e"
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "closing"
   },
   "source": "## 11. Özet\n\n| Soru | Kısa cevap |\n|------|------------|\n| Klasik sayı qubit’e nasıl girer? | Basis, angle, amplitude veya feature map |\n| QML’de en pratik? | Angle + ZZFeatureMap |\n| En kompakt? | Amplitude ($2^n$ → $n$ qubit) |\n| Donanımda ne tercih? | Sığ angle/ZZ, az reps, az qubit |\n| Encoding sonrası ne olur? | Ansatz (VQC) veya kernel / ölçüm |\n\n### Öğrenci ödevleri\n1. Aynı $x$ için RY vs RX fidelity farkını ölçün  \n2. `reps=1,2,3` ile ZZFeatureMap derinliğini ve fidelity ayrımını karşılaştırın  \n3. 4 özellikli veriyi dense angle (2 qubit) ile kodlayın  \n4. Amplitude encoding’de padding + norm adımlarını elle yazın  \n\n---\n**Hazırlayan:** Joseph Volkan Ozcan\n**Teknoloji:** Qiskit · Aer · Circuit Library  \n**Ortam:** Google Colab · 2026\n",
   "id": "closing"
  }
 ]
}