{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 量子退火、量子啟發退火與模擬退火之QUBO程式設計\n",
        "# (QUBO Programming for Quantum Annealing, Quantum-inspired Annealing and Simulated Annealing)\n",
        "\n",
        "### 概述:\n",
        "\n",
        "####       不管是屬於量子計算的量子退火機(quantum annealer)或是屬於古典計算的量子啟發退火機(quantum-inspired annealer)與模擬退火(simulated annealing, SA)演算法，都可以透過二次無約束二元最佳化(quadratic unconstrained binary optimization, QUBO)公式或是伊辛模型(Ising model)來解決複雜的問題，如組合最佳化問題(combinatorial optimization problem, COP)。\n",
        "\n",
        "####       以下我們介紹QUBO公式、伊辛模型、PyQUBO套件，並說明如何藉由安裝D-Wave量子退火套件與PyQUBO套件，以撰寫Python程式解決無約束條件(constraint)的COP，如子集合加總(subset sum problem, SSP)、最大割(maximum cut problem, MCP)。之後，我們介紹如何於QUBO公式中加入約束條件，以解決具約束條件的COP，如節點覆蓋問題(vertex cover problem, VCP)。最後，我們介紹如何調整具約束條件的QUBO公式以優化解答的品質。"
      ],
      "metadata": {
        "id": "GXmHQYNBKe5O"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## QUBO公式簡介\n",
        "QUBO代表「二次無約束二元最佳化(Quadratic Unconstrained Binary Optimization)」[1]。QUBO公式是表達最佳化問題的的一種標準形式（canonical form），可以透過調整一組二元變數(binary variable)來最小化一個二次(quadratic)目標函數(objective function)。QUBO公式主要形式如下：\n",
        "\n",
        "\\begin{equation}\n",
        "\\min_{x \\in \\{0,1\\}^n} f(x) \\;=\\; \\sum_{i} Q_{ii}x_i \\;+\\; \\sum_{i<j} Q_{ij}x_i x_j \\;+\\; c.\n",
        "\\end{equation}\n",
        "\n",
        "上式中$x_i$​ 為二元決策變數（其值為0 或 1），或是等義的，$x = (x_1, x_2, \\dots, x_n)^\\top \\in \\{0,1\\}^n$ 是二元決策變數向量，$Q_{ii}$是一次項係數，$Q_{ij}$​ 是二次項係數，而$c$是常數。\n",
        "\n",
        "由於$x_i$的值為0 或 1，因此$x_i=x_i^2$，所以QUBO公式也可以寫成全部為二次項的形式:\n",
        "\n",
        "\\begin{equation}\n",
        "\\min_{x \\in \\{0,1\\}^n} f(x) \\;=\\; \\sum_{i} Q_{ii}x_i^2 \\;+\\; \\sum_{i<j} Q_{ij}x_i x_j \\;+\\; c.\n",
        "\\end{equation}\n",
        "\n",
        "或是QUBO公式也可以寫成以下的矩陣形式:\n",
        "\n",
        "$$\\min_{x \\in \\{0,1\\}^n} f(x) \\;=\\;x^\\top Q x \\;+\\; c, $$\n",
        "\n",
        "\n",
        "\n",
        "其中， $x = (x_1, x_2, \\dots, x_n)^\\top \\in \\{0,1\\}^n$ 是二元決策向量；$Q$ 是一個大小為$n\\times n$的上三角係數矩陣，也就是$Q_{ij}=0$針對$i>j$，而$c$ 是常數項。\n",
        "\n",
        "\n",
        "以下更詳細的展開，令\n",
        "\n",
        "$$Q = \\begin{bmatrix}\n",
        "Q_{11} & Q_{12} & \\cdots & Q_{1n} \\\\\n",
        "Q_{21} & Q_{22} & \\cdots & Q_{2n} \\\\\n",
        "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
        "Q_{n1} & Q_{n2} & \\cdots & Q_{nn}\n",
        "\\end{bmatrix},\n",
        "\\quad\n",
        "x = \\begin{bmatrix}\n",
        "x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n\n",
        "\\end{bmatrix},\n",
        "$$\n",
        "則有\n",
        "\n",
        "$$x^\\top Q x \\;=\\; \\sum_{i=1}^n \\sum_{j=1}^n Q_{ij} x_i x_j.\n",
        "$$\n",
        "\n",
        "我們也可以將$Q$改為對稱矩陣（即 $Q_{ij} = Q_{ji}$），則需要常將原本的上三角矩陣係數平均分配一半到下三角矩陣係數中。具體定義為：\n",
        "$$\n",
        "Q^{\\text{sym}}_{ij} = \\begin{cases}\n",
        "Q_{ii}, & i=j, \\\\\n",
        "\\frac{1}{2}Q_{ij}, & i \\ne j,\n",
        "\\end{cases}\n",
        "$$\n",
        "\n",
        "此時可保證\n",
        "$$\n",
        "x^\\top Q^{\\text{sym}} x \\;=\\; \\sum_i Q_{ii}x_i \\;+\\; \\sum_{i<j} Q_{ij}x_i x_j.\n",
        "$$\n",
        "\n",
        "在實作時，常透過對稱化處理將 $Q$ 視為對稱矩陣。\n",
        "\n",
        "總的來說，QUBO公式具有「通用容器」特性：許多組合最佳化問題(Combinatorial Optimization Problems, COPs)，例如最大割問題(Max-Cut Problem, MCP)、旅行推銷員問題(Traveling Salesperson Problem, TSP)、圖著色問題(Graph Coloring Problem, GCP)、二次指派問題(Quadratic Assignment Problem, QAP)、0/1背包問題(0/1 Knapsack Problem, 0/1 KP)以及子集加總問題 (Subset Sum Problem, SSP)等，皆可以使用QUBO公式建模。稍後我們會說明，除了COP本身的最佳化目標之外，若COP帶有約束條件(constraint condition)，則約束條件會以懲罰項嵌入目標函數中。\n",
        "\n",
        "\n",
        "## 伊辛(Ising)模型簡介\n",
        "\n",
        "伊辛(Ising)模型[2]最初由德國物理學家Ernst Ising於1925年提出，作為一個研究鐵磁性（ferromagnetism）的理論模型，用來描述鐵磁材料中自旋系統的總能量（Hamiltonian）。伊辛模型使用自旋變數 $s_i \\in \\{-1,+1\\}$，其能量常寫作\n",
        "\\begin{equation}\n",
        "E(s) \\;=\\; \\sum_{i} h_i s_i \\;+\\; \\sum_{i<j} J_{ij} s_i s_j \\;+\\; \\mathrm{const},\n",
        "\\end{equation}\n",
        "其中 $h_i$ 為外場（bias），$J_{ij}$ 為耦合（coupler）。\n",
        "\n",
        "## QUBO公式與Ising模型應用\n",
        "QUBO公式與Ising模型可以精確的互相轉換，說明如下:\n",
        "\n",
        "令\n",
        "$$\n",
        "x_i \\;=\\; \\frac{1+s_i}{2} \\quad (\\;x_i \\in \\{0,1\\},\\,s_i \\in \\{-1,+1\\}\\;)\n",
        "$$\n",
        "代入QUBO公式可得Ising參數：\n",
        "\\begin{align}\n",
        "J_{ij} &= \\frac{Q_{ij}}{4} \\quad (i<j), \\\\\n",
        "h_i &= \\frac{Q_{ii}}{2} \\;+\\; \\frac{1}{4}\\sum_{j \\ne i} Q_{ij}, \\\\\n",
        "\\mathrm{const} &= c \\;+\\; \\frac{1}{2}\\sum_i Q_{ii} \\;+\\; \\frac{1}{4}\\sum_{i<j} Q_{ij}.\n",
        "\\end{align}\n",
        "反向亦成立：若已知 Ising $(h,J)$，令 $s_i=2x_i-1$ 並整理，\n",
        "\\begin{align}\n",
        "Q_{ij} &= 4J_{ij} \\quad (i<j), \\\\\n",
        "Q_{ii} &= 2h_i \\;-\\; 2\\!\\sum_{j\\ne i} J_{ij}, \\\\\n",
        "c &= \\mathrm{const} \\;+\\; \\sum_i h_i \\;+\\; \\sum_{i<j} J_{ij}.\n",
        "\\end{align}\n",
        "\n",
        "此對應確保QUBO公式能對接Ising模型，而Ising模型也能轉成QUBO公式。此形式正是量子退火機(quantum annealer)（如 D-Wave公司的Advantage [3]）、量子啟發退火機(quantum-inspired annealer)（如日本Fujitsu公司的Digital Annealer [4]與日本Hitachi公司的FPGA/CMOS退火機 [5]）、光學相干伊辛機(Coherent Ising Machine, CIM)(如史丹佛大學與日本NTT研究團隊提出的CIM [6])與許多古典啟發式最佳化演算法(如模擬退火(Simulated Annealing, SA)演算法[7]以及禁忌搜尋(Tabu Search)演算法[8]）所處理的標的。\n",
        "\n",
        "\n",
        "[1] Glover, F., Kochenberger, G., & Du, Y. (2018). A tutorial on formulating and using QUBO models. arXiv preprint arXiv:1811.11538.\n",
        "\n",
        "[2] Ising, E. (1925). Beitrag zur theorie des ferromagnetismus. Zeitschrift für Physik, 31(1), 253-258.\n",
        "\n",
        "[3] Johnson, M. W., Amin, M. H., Gildert, S., Lanting, T., Hamze, F., Dickson, N., ... & Rose, G. (2011). Quantum annealing with manufactured spins. Nature, 473(7346), 194-198.\n",
        "\n",
        "[4] Aramon, M., Rosenberg, G., Valiante, E., Miyazawa, T., Tamura, H., & Katzgraber, H. G. (2019). Physics-inspired optimization for quadratic unconstrained problems using a digital annealer. Frontiers in Physics, 7, 48.\n",
        "\n",
        "[5] Inagaki, T., Haribara, Y., Igarashi, K., Sonobe, T., Tamate, S., Honjo, T., ... & Takesue, H. (2016). A coherent Ising machine for 2000-node optimization problems. Science, 354(6312), 603-606.\n",
        "\n",
        "[6] Yamaoka, M., Yoshimura, C., Hayashi, M., Okuyama, T., Aoki, H., & Mizuno, H. (2015). A 20k-spin Ising chip to solve combinatorial optimization problems with CMOS annealing. IEEE Journal of Solid-State Circuits, 51(1), 303-309.\n",
        "\n",
        "[7] Kirkpatrick, S., Gelatt Jr, C. D., & Vecchi, M. P. (1983). Optimization by simulated annealing. science, 220(4598), 671-680.\n",
        "\n",
        "[8] Glover, F. (1989). Tabu search—part I. ORSA Journal on computing, 1(3), 190-206."
      ],
      "metadata": {
        "id": "9qSa6qM5j6pp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PyQUBO 的源起與歷史\n",
        "\n",
        "## 起源背景\n",
        "QUBO（Quadratic Unconstrained Binary Optimization，二次無約束二元最佳化）與 Ising 模型是各種**組合最佳化問題**的通用表述方式。隨著 D-Wave 量子退火機與各種伊辛機 (Ising machines) 的出現，研究者需要一個方便的程式工具，將現實問題快速轉換為 QUBO/Ising 形式。  \n",
        "\n",
        "為此，**Recruit Communications Co., Ltd.** 的研究團隊開發了 **PyQUBO** —— 一個以 Python 實現的 **DSL（Domain Specific Language）**，能夠以數學表達式方式建構 QUBO 模型，並自動輸出可供 D-Wave Ocean SDK 或其他 BQM（Binary Quadratic Model）相容框架使用的格式。  \n",
        "\n",
        "---\n",
        "\n",
        "## 歷史沿革\n",
        "- **2019 年**：在 *Journal of the Physical Society of Japan* 發表的文章中首次介紹了 PyQUBO 的設計理念【Tanahashi et al., 2019】。該論文討論了伊辛機的應用以及對應的軟體開發工具，其中就包含 PyQUBO 的初版構想。  \n",
        "- **2021 年**：PyQUBO 的完整介紹與功能發表於 *IEEE Transactions on Computers*【Zaman, Tanahashi & Tanaka, 2021】。同時在 arXiv 發表技術報告 (arXiv:2103.01708)，詳細介紹了 Constraint、Placeholder 與 Integer 類別的設計。  \n",
        "- **GitHub 開源**：專案由 Recruit Communications Co., Ltd. 在 GitHub 公開，維護者包含 **Kotaro Tanahashi** 與 **Shu Tanaka** 等人。其後與 C++ 庫 **cimod** 整合以提升效能。  \n",
        "- **後續更新**：PyQUBO 持續維護至今，支援 Python 3.13，並保持與 D-Wave Ocean 生態系整合。\n",
        "\n",
        "---\n",
        "\n",
        "## 作者與單位\n",
        "- **主要作者**：\n",
        "  - Mashiyat Zaman  \n",
        "  - Kotaro Tanahashi  \n",
        "  - Shu Tanaka  \n",
        "\n",
        "- **所屬單位**：Recruit Communications Co., Ltd., Japan\n",
        "\n",
        "---\n",
        "\n",
        "## 設計理念\n",
        "PyQUBO 的設計目標是讓使用者以「數學表達式」描述最佳化問題，透過編譯器將其轉換為 QUBO 或 Ising 形式，並提供：\n",
        "- **Constraint**：可將約束條件嵌入 QUBO。  \n",
        "- **Placeholder**：允許在不重新編譯的情況下調整懲罰參數。  \n",
        "- **Integer**：提供整數變數的編碼支援。  \n",
        "\n",
        "這些功能使得 PyQUBO 特別適合於實驗性建模與快速原型開發。\n",
        "\n",
        "---\n",
        "\n",
        "## 參考文獻\n",
        "- Tanahashi, K., Takayanagi, S., Motohashi, T., & Tanaka, S. (2019). *Application of Ising Machines and a Software Development for Ising Machines*. Journal of the Physical Society of Japan, 88(6), 061010. https://doi.org/10.7566/JPSJ.88.061010  \n",
        "\n",
        "- Zaman, M., Tanahashi, K., & Tanaka, S. (2021). *PyQUBO: Python Library for Mapping Combinatorial Optimization Problems to QUBO Form*. IEEE Transactions on Computers, 70(8), 1201–1213. https://doi.org/10.1109/TC.2021.3065091  \n",
        "\n",
        "- GitHub Repository: https://github.com/recruit-communications/pyqubo  \n",
        "- PyQUBO Documentation: https://pyqubo.readthedocs.io/\n"
      ],
      "metadata": {
        "id": "1gx-Tyituftr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##子集合加總問題之QUBO解題程式設計\n",
        "\n",
        "子集合加總問題(subset sum problem, SSP) 是一個經典的 NP 完全(NP-Complete, NPC)問題。給定一組整數和一個目標值 target，目標是在這些整數中找出一個子集，使其中元素的總和等於 target。\n",
        "### 問題定義\n",
        "\n",
        "假設我們有一組整數 ${A_1,A_2,…,A_n}$ 和一個目標值 target，我們希望選擇這組整數的某個子集，使其和為 target。我們可以將此問題轉換為 QUBO 的形式，具體步驟如下：\n",
        "\n",
        "### 定義二元變數：\n",
        "將每個整數 $A_i$​ 對應到一個二元變數 $x_i$​，若 $x_i=1$，表示選擇 $A_i$​ 作為子集的一部分；若 $x_i=0$，表示不選擇該數。\n",
        "\n",
        "###構建 QUBO 目標函數：\n",
        "\n",
        "目標是使選擇的整數總和與target盡可能接近，即希望滿足：\n",
        "\n",
        "\n",
        "$\\Sigma_i^n A_i x_i = target$\n",
        "\n",
        "將其轉換為一個 QUBO 目標函數，可以表示為對此總和與目標值target之間的差平方最小化：\n",
        "\n",
        "$(\\Sigma_i^n A_i x_i - target)^2 $\n",
        "\n",
        "###展開並簡化：\n",
        "\n",
        "將上述目標函數展開後，我們得到一個二次項與一次項組成的函數：\n",
        "\n",
        "其中常數項對優化過程無影響，可以忽略。因此我們最小化以下目標函數：\n",
        "\n",
        "###轉換成 QUBO 矩陣：\n",
        "根據展開的式子，我們可以將 QUBO 問題表示為矩陣 Q 的形式，並將其輸入量子計算機或古典最佳化演算法求解。\n",
        "\n",
        "## SSP之QUBO求解程式\n",
        "\n",
        "以下我們分段展示解決SSP之QUBO程式"
      ],
      "metadata": {
        "id": "EC2PQXN6LSPo"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "fVwhYb2J0p7k",
        "outputId": "c5ee028b-739a-470b-8800-129a2c69c79c",
        "collapsed": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting dwave-ocean-sdk\n",
            "  Downloading dwave_ocean_sdk-9.5.0-py3-none-any.whl.metadata (5.9 kB)\n",
            "Collecting dimod==0.12.22 (from dwave-ocean-sdk)\n",
            "  Downloading dimod-0.12.22-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (3.1 kB)\n",
            "Collecting dwave-cloud-client==0.14.8 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_cloud_client-0.14.8-py3-none-any.whl.metadata (5.5 kB)\n",
            "Collecting dwave-gate==0.6.0 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_gate-0.6.0-py3-none-any.whl.metadata (3.8 kB)\n",
            "Collecting dwave-graphs==1.1.0 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_graphs-1.1.0-py3-none-any.whl.metadata (2.9 kB)\n",
            "Collecting dwave-hybrid==0.6.16 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_hybrid-0.6.16-py3-none-any.whl.metadata (4.5 kB)\n",
            "Collecting dwave-inspector==0.5.5 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_inspector-0.5.5-py3-none-any.whl.metadata (4.4 kB)\n",
            "Collecting dwave-networkx==0.8.19 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_networkx-0.8.19-py3-none-any.whl.metadata (2.8 kB)\n",
            "Collecting dwave-optimization==0.7.3 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_optimization-0.7.3-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl.metadata (5.6 kB)\n",
            "Collecting dwave-preprocessing==0.6.11 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_preprocessing-0.6.11-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (3.5 kB)\n",
            "Collecting dwave-samplers==1.8.0 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_samplers-1.8.0-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (24 kB)\n",
            "Collecting dwave-system==1.36.0 (from dwave-ocean-sdk)\n",
            "  Downloading dwave_system-1.36.0-py3-none-any.whl.metadata (4.0 kB)\n",
            "Collecting minorminer==0.2.22 (from dwave-ocean-sdk)\n",
            "  Downloading minorminer-0.2.22-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl.metadata (7.9 kB)\n",
            "Collecting penaltymodel==1.3.0 (from dwave-ocean-sdk)\n",
            "  Downloading penaltymodel-1.3.0-py3-none-any.whl.metadata (3.4 kB)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.13/dist-packages (from dimod==0.12.22->dwave-ocean-sdk) (2.1.3)\n",
            "Requirement already satisfied: requests<3,>=2.25 in /usr/local/lib/python3.13/dist-packages (from requests[socks]<3,>=2.25->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2.32.4)\n",
            "Requirement already satisfied: urllib3<3,>=1.26 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2.5.0)\n",
            "Requirement already satisfied: pydantic<3,>=2 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2.13.5)\n",
            "Collecting homebase<2,>=1.0 (from dwave-cloud-client==0.14.8->dwave-ocean-sdk)\n",
            "  Downloading homebase-1.0.1-py2.py3-none-any.whl.metadata (3.3 kB)\n",
            "Requirement already satisfied: click<9,>=8.2 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (8.5.0)\n",
            "Requirement already satisfied: python-dateutil<3,>=2.7 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2.9.0.post0)\n",
            "Collecting plucky<0.5,>=0.4.3 (from dwave-cloud-client==0.14.8->dwave-ocean-sdk)\n",
            "  Downloading plucky-0.4.3-py2.py3-none-any.whl.metadata (4.4 kB)\n",
            "Collecting diskcache<6,>=5.2.1 (from dwave-cloud-client==0.14.8->dwave-ocean-sdk)\n",
            "  Downloading diskcache-5.6.3-py3-none-any.whl.metadata (20 kB)\n",
            "Requirement already satisfied: packaging>=19 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (26.3)\n",
            "Requirement already satisfied: werkzeug<4,>=3.1.0 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (3.1.8)\n",
            "Requirement already satisfied: typing-extensions<5,>=4.5.0 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (4.16.0)\n",
            "Requirement already satisfied: authlib<2,>=1.2 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (1.8.0)\n",
            "Requirement already satisfied: importlib_metadata>=5.0.0 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (9.0.1)\n",
            "Requirement already satisfied: orjson>=3.11 in /usr/local/lib/python3.13/dist-packages (from dwave-cloud-client==0.14.8->dwave-ocean-sdk) (3.12.0)\n",
            "Collecting http-sf>=1.2.1 (from dwave-cloud-client==0.14.8->dwave-ocean-sdk)\n",
            "  Downloading http_sf-1.3.0-py3-none-any.whl.metadata (6.7 kB)\n",
            "Collecting addict (from dwave-gate==0.6.0->dwave-ocean-sdk)\n",
            "  Downloading addict-2.4.0-py3-none-any.whl.metadata (1.0 kB)\n",
            "Requirement already satisfied: polars>=1.35 in /usr/local/lib/python3.13/dist-packages (from dwave-gate==0.6.0->dwave-ocean-sdk) (1.35.2)\n",
            "Requirement already satisfied: networkx<4,>=3.2 in /usr/local/lib/python3.13/dist-packages (from dwave-graphs==1.1.0->dwave-ocean-sdk) (3.6.1)\n",
            "Requirement already satisfied: Flask<4,>=2.2 in /usr/local/lib/python3.13/dist-packages (from dwave-inspector==0.5.5->dwave-ocean-sdk) (3.1.3)\n",
            "Requirement already satisfied: scipy>=1.13 in /usr/local/lib/python3.13/dist-packages (from dwave-system==1.36.0->dwave-ocean-sdk) (1.16.3)\n",
            "Collecting fasteners>=0.15 (from minorminer==0.2.22->dwave-ocean-sdk)\n",
            "  Downloading fasteners-0.20-py3-none-any.whl.metadata (4.8 kB)\n",
            "Requirement already satisfied: cryptography>=45.0.1 in /usr/local/lib/python3.13/dist-packages (from authlib<2,>=1.2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (50.0.1)\n",
            "Requirement already satisfied: joserfc>=1.6.1 in /usr/local/lib/python3.13/dist-packages (from authlib<2,>=1.2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (1.7.5)\n",
            "Requirement already satisfied: blinker>=1.9.0 in /usr/local/lib/python3.13/dist-packages (from Flask<4,>=2.2->dwave-inspector==0.5.5->dwave-ocean-sdk) (1.9.0)\n",
            "Requirement already satisfied: itsdangerous>=2.2.0 in /usr/local/lib/python3.13/dist-packages (from Flask<4,>=2.2->dwave-inspector==0.5.5->dwave-ocean-sdk) (2.2.0)\n",
            "Requirement already satisfied: jinja2>=3.1.2 in /usr/local/lib/python3.13/dist-packages (from Flask<4,>=2.2->dwave-inspector==0.5.5->dwave-ocean-sdk) (3.1.6)\n",
            "Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.13/dist-packages (from Flask<4,>=2.2->dwave-inspector==0.5.5->dwave-ocean-sdk) (3.0.3)\n",
            "Requirement already satisfied: zipp>=3.20 in /usr/local/lib/python3.13/dist-packages (from importlib_metadata>=5.0.0->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (4.1.0)\n",
            "Requirement already satisfied: polars-runtime-32==1.35.2 in /usr/local/lib/python3.13/dist-packages (from polars>=1.35->dwave-gate==0.6.0->dwave-ocean-sdk) (1.35.2)\n",
            "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.13/dist-packages (from pydantic<3,>=2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (0.8.0)\n",
            "Requirement already satisfied: pydantic-core==2.46.5 in /usr/local/lib/python3.13/dist-packages (from pydantic<3,>=2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2.46.5)\n",
            "Requirement already satisfied: typing-inspection>=0.4.2 in /usr/local/lib/python3.13/dist-packages (from pydantic<3,>=2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (0.4.4)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.13/dist-packages (from python-dateutil<3,>=2.7->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (1.17.0)\n",
            "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.13/dist-packages (from requests<3,>=2.25->requests[socks]<3,>=2.25->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (3.4.9)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.13/dist-packages (from requests<3,>=2.25->requests[socks]<3,>=2.25->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (3.19)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.13/dist-packages (from requests<3,>=2.25->requests[socks]<3,>=2.25->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2026.7.22)\n",
            "Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in /usr/local/lib/python3.13/dist-packages (from requests[socks]<3,>=2.25->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (1.7.1)\n",
            "Requirement already satisfied: cffi>=2.0.0 in /usr/local/lib/python3.13/dist-packages (from cryptography>=45.0.1->authlib<2,>=1.2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (2.1.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.13/dist-packages (from cffi>=2.0.0->cryptography>=45.0.1->authlib<2,>=1.2->dwave-cloud-client==0.14.8->dwave-ocean-sdk) (3.0)\n",
            "Downloading dwave_ocean_sdk-9.5.0-py3-none-any.whl (8.5 kB)\n",
            "Downloading dimod-0.12.22-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (8.7 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.7/8.7 MB\u001b[0m \u001b[31m39.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_cloud_client-0.14.8-py3-none-any.whl (170 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m170.9/170.9 kB\u001b[0m \u001b[31m14.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_gate-0.6.0-py3-none-any.whl (97 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.1/97.1 kB\u001b[0m \u001b[31m8.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_graphs-1.1.0-py3-none-any.whl (107 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m107.3/107.3 kB\u001b[0m \u001b[31m9.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_hybrid-0.6.16-py3-none-any.whl (78 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.5/78.5 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_inspector-0.5.5-py3-none-any.whl (30 kB)\n",
            "Downloading dwave_networkx-0.8.19-py3-none-any.whl (106 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m106.8/106.8 kB\u001b[0m \u001b[31m10.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_optimization-0.7.3-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl (15.3 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m15.3/15.3 MB\u001b[0m \u001b[31m76.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_preprocessing-0.6.11-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (3.4 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.4/3.4 MB\u001b[0m \u001b[31m89.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_samplers-1.8.0-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (2.5 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.5/2.5 MB\u001b[0m \u001b[31m88.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dwave_system-1.36.0-py3-none-any.whl (120 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m120.8/120.8 kB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading minorminer-0.2.22-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl (4.0 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.0/4.0 MB\u001b[0m \u001b[31m103.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading penaltymodel-1.3.0-py3-none-any.whl (36 kB)\n",
            "Downloading diskcache-5.6.3-py3-none-any.whl (45 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m45.5/45.5 kB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading fasteners-0.20-py3-none-any.whl (18 kB)\n",
            "Downloading homebase-1.0.1-py2.py3-none-any.whl (11 kB)\n",
            "Downloading http_sf-1.3.0-py3-none-any.whl (22 kB)\n",
            "Downloading plucky-0.4.3-py2.py3-none-any.whl (10 kB)\n",
            "Downloading addict-2.4.0-py3-none-any.whl (3.8 kB)\n",
            "Installing collected packages: plucky, homebase, addict, http-sf, fasteners, dwave-optimization, diskcache, dimod, penaltymodel, dwave-samplers, dwave-preprocessing, dwave-networkx, dwave-graphs, minorminer, dwave-cloud-client, dwave-system, dwave-gate, dwave-inspector, dwave-hybrid, dwave-ocean-sdk\n",
            "Successfully installed addict-2.4.0 dimod-0.12.22 diskcache-5.6.3 dwave-cloud-client-0.14.8 dwave-gate-0.6.0 dwave-graphs-1.1.0 dwave-hybrid-0.6.16 dwave-inspector-0.5.5 dwave-networkx-0.8.19 dwave-ocean-sdk-9.5.0 dwave-optimization-0.7.3 dwave-preprocessing-0.6.11 dwave-samplers-1.8.0 dwave-system-1.36.0 fasteners-0.20 homebase-1.0.1 http-sf-1.3.0 minorminer-0.2.22 penaltymodel-1.3.0 plucky-0.4.3\n",
            "Collecting pyqubo\n",
            "  Downloading pyqubo-1.5.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (7.0 kB)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.13/dist-packages (from pyqubo) (2.1.3)\n",
            "Requirement already satisfied: dimod<0.13,>=0.9.14 in /usr/local/lib/python3.13/dist-packages (from pyqubo) (0.12.22)\n",
            "Collecting dwave-neal>=0.5.7 (from pyqubo)\n",
            "  Downloading dwave_neal-0.6.0-py3-none-any.whl.metadata (3.0 kB)\n",
            "Collecting Deprecated>=1.2.12 (from pyqubo)\n",
            "  Downloading deprecated-1.3.1-py2.py3-none-any.whl.metadata (5.9 kB)\n",
            "Requirement already satisfied: six>=1.15.0 in /usr/local/lib/python3.13/dist-packages (from pyqubo) (1.17.0)\n",
            "Requirement already satisfied: wrapt<3,>=1.10 in /usr/local/lib/python3.13/dist-packages (from Deprecated>=1.2.12->pyqubo) (2.4.0)\n",
            "Requirement already satisfied: dwave-samplers<2.0.0,>=1.0.0 in /usr/local/lib/python3.13/dist-packages (from dwave-neal>=0.5.7->pyqubo) (1.8.0)\n",
            "Requirement already satisfied: networkx<4,>=3 in /usr/local/lib/python3.13/dist-packages (from dwave-samplers<2.0.0,>=1.0.0->dwave-neal>=0.5.7->pyqubo) (3.6.1)\n",
            "Downloading pyqubo-1.5.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (256 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m256.9/256.9 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading deprecated-1.3.1-py2.py3-none-any.whl (11 kB)\n",
            "Downloading dwave_neal-0.6.0-py3-none-any.whl (8.7 kB)\n",
            "Installing collected packages: Deprecated, dwave-neal, pyqubo\n",
            "Successfully installed Deprecated-1.3.1 dwave-neal-0.6.0 pyqubo-1.5.0\n"
          ]
        }
      ],
      "source": [
        "# 安裝 D-Wave 量子退火套件與PyQUBO套件\n",
        "!pip install dwave-ocean-sdk\n",
        "!pip install pyqubo"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "引入 Pyqubo 中的 Binary 變數類別\n",
        "更多資料：https://pyqubo.readthedocs.io/en/latest/reference/express.html?highlight=binary#pyqubo.Binary\n",
        "\"\"\"\n",
        "from pyqubo import Binary"
      ],
      "metadata": {
        "id": "bDbtmRWG1Jwa"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 定義子集合問題資料\n",
        "A = [1, 2, 3, 4] # 定義集合元素\n",
        "n = len(A)\n",
        "target = 5 # 定義子集和的目標"
      ],
      "metadata": {
        "id": "MNczbeL91bFa"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "宣告一個變數 H，H 表示 Hamiltonian 是描述系統能量的函數，我們將需要最小化的函數視為系統能量（Hamiltonian），定義目標函數。\n",
        "首先，我們需要初始化 H 變數為 0 即可。\n",
        "\"\"\"\n",
        "H = 0\n",
        "\n",
        "\"\"\"\n",
        "因為我們有 n 個元素，所以定義 n 個二元變數，xi 變數用來決定集合中的第 i 個元素是否放入子集中（如果 xi 為 1 則放入，為 0 則不放入）。\n",
        "e.g. x = [Binary(x0), Binary(x1), Binary(x2), Binary(x3)]。\n",
        "Binary 是宣告二元變數變數，讓程式知道這是二元變數，Pyqubo 就會將 H 視為一個可以轉換成 QUBO 的目標函數。\n",
        "Binary(\"x\") 是指建構一個 Label 為 \"x\" 的 Binary 變數 Object\n",
        "\"\"\"\n",
        "x = [Binary('x'+str(i)) for i in range(n)]"
      ],
      "metadata": {
        "id": "Ymnd8iCS1mep"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "定義目標函式，\n",
        "首先，我們將計算 A[i]*x[i] 總和\n",
        "e.g. H = A[0]*x[0]+A[1]*x[1]+A[2]*x[2]+A[3]*x[3]\n",
        "\n",
        "接著我們將這個總和減去目標後平方。\n",
        "e.g. H = ((A[0]*x[0]+A[1]*x[1]+A[2]*x[2]+A[3]*x[3])-5)^2\n",
        "\n",
        "量子退火的目標是要找到若干組 x 變數的值（0 或 1）可以使得能量（H）最小。\n",
        "\"\"\"\n",
        "for i in range(len(A)): # 總和所有的 A[i] * x[i]\n",
        "  H += A[i]*x[i]\n",
        "\n",
        "H -= target # (總和 - 目標)\n",
        "H = H*H # (總和 - 目標)^2"
      ],
      "metadata": {
        "id": "jH2Vua7TR5pU"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "最後，我們要將目標函式編譯成 QUBO 形式。\n",
        "H.compile() 將 H 編譯成 Pyqubo 的 Model 物件，這個 Model 物件是一個用來描述目標函式的抽象物件，它具備將目標函式轉換成 qubo、ising、bqm 等形式的 Method。\n",
        "[Model 文件](https://pyqubo.readthedocs.io/en/latest/reference/model.html#pyqubo.to_qubo)\n",
        "\n",
        "model.to_qubo() 會回傳一個 tuple 為 (QUBO矩陣, 能量偏移量 offset)，QUBO 矩陣是用一個字典（dictionary）描述，格式為 {('變數j', '變數i'): Qij 的值}，另外 Qij 的值同時就代表 QUBO 中 xi*xj 項的係數。\n",
        "[to_qubo() 文件](https://pyqubo.readthedocs.io/en/latest/reference/model.html#pyqubo.to_qubo)\n",
        "註：offset 是 pyqubo 轉換為 qubo 的過程中所產生的常數項，通常可以忽略。在後續的返回的結果中得到的 energy 加上 offset 就是我們原先定義 H 的值。\n",
        "\"\"\"\n",
        "model = H.compile()\n",
        "Q, offset = model.to_qubo() # 將目標函數轉換成 QUBO 形式\n",
        "print(Q) # 印出 QUBO 矩陣"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "eOQM645_R6p1",
        "outputId": "a742f916-e495-461d-bd47-20c427ff31f6"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{('x2', 'x0'): 6.0, ('x3', 'x2'): 24.0, ('x3', 'x3'): -24.0, ('x2', 'x1'): 12.0, ('x3', 'x1'): 16.0, ('x3', 'x0'): 8.0, ('x2', 'x2'): -21.0, ('x0', 'x0'): -9.0, ('x1', 'x0'): 4.0, ('x1', 'x1'): -16.0}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from dwave.samplers import SimulatedAnnealingSampler\n",
        "sampler = SimulatedAnnealingSampler() # 宣告 Sampler\n",
        "sampleset = sampler.sample_qubo(Q, num_reads=1000) # 求解 Q，取樣 1000 次\n",
        "best_sample = sampleset.first.sample # 將能量最低的解拿出來\n",
        "print(\"best solution: \", best_sample)\n",
        "print(\"Hamiltonian: \", sampleset.first.energy+offset)"
      ],
      "metadata": {
        "id": "H2xhciho2DNY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "a3fe8aaf-16b8-4ba8-cbff-bd9851e6cee8"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "best solution:  {'x0': np.int8(1), 'x1': np.int8(0), 'x2': np.int8(0), 'x3': np.int8(1)}\n",
            "Hamiltonian:  0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 檢查解答是否符合要求\n",
        "total = 0\n",
        "for i in range(len(A)):\n",
        "    if best_sample[f'x{i}'] == 1:\n",
        "        total += A[i]\n",
        "\n",
        "print(total == target)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "0BbMVJTO28zN",
        "outputId": "feba2bc0-d8e6-42a3-c498-2b50cd924627"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 最大割問題之QUBO解題程式設計\n",
        "\n",
        "最大割問題(max-cut problem, or maximum cut problem, MCP)也是一個經典的NP完全(NP-Complete, NPC)問題\n",
        "\n",
        "### Max-Cut問題之定義\n",
        "\n",
        "考慮一個加權無向圖 $G=(V,E)$，其中 $V$ 為節點集合，$E$ 為邊集合，且邊 $(i,j) \\in E$ 具有權重 $w_{ij} \\geq 0$。Max-Cut問題的目標是將節點集合 $V$ 劃分為兩個互不相交(mutually disjoint)的子集合 $S$ 與 $V - S$，使得跨越這兩個子集合的邊之權重總和最大化。\n",
        "\n",
        "### 定義二元變數：\n",
        "\n",
        "對於每個節點 $i \\in V$，定義二元變數\n",
        "$$\n",
        "x_i =\n",
        "\\begin{cases}\n",
        "1, & \\text{若 } i \\in S, \\\\\n",
        "0, & \\text{若 } i \\in V - S.\n",
        "\\end{cases}\n",
        "$$\n",
        "\n",
        "此時，一個邊 $(i,j)$ 被切割（即一端在 $S$，另一端在 $V - S$）的指示函數(indicator function)可寫為：\n",
        "\n",
        "$$\n",
        "\\mathbf{1}[x_i \\neq x_j] = x_i + x_j - 2x_i x_j.\n",
        "$$\n",
        "\n",
        "因此，MCP的最大化形式為：\n",
        "\n",
        "$$\n",
        "\\max \\;\\; \\sum_{(i,j)\\in E} w_{ij} \\, \\mathbf{1}[x_i \\neq x_j].\n",
        "$$\n",
        "\n",
        "由於 QUBO 通常寫作最小化問題，我們將上述目標乘上 $-1$，得到：\n",
        "\n",
        "$$\n",
        "\\min \\; \\sum_{(i,j)\\in E} \\bigl(-w_{ij}x_i - w_{ij}x_j + 2w_{ij}x_i x_j \\bigr).\n",
        "$$\n",
        "\n",
        "換句話說，每個邊 $(i,j)$ 權重 $w$ 在 QUBO 矩陣 $Q$ 中的貢獻為：\n",
        "\n",
        "$$\n",
        "Q_{ii} \\mathrel{+}= -w, \\qquad\n",
        "Q_{jj} \\mathrel{+}= -w, \\qquad\n",
        "Q_{ij} \\mathrel{+}= 2w \\quad (i<j).\n",
        "$$\n",
        "\n",
        "考慮一個加權無向圖 $G=(V,E)$，其中節點集合 $V=\\{1,2,3,4\\}$，邊集合及其權重如下：\n",
        "$$\n",
        "E = \\{(1,2):1,\\; (1,3):2,\\; (2,3):3,\\; (2,4):2,\\; (3,4):1\\}.\n",
        "$$"
      ],
      "metadata": {
        "id": "7jkL0xrhEBEn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "加權無向圖$G$如下所示:\n",
        "<img src=\"attachment:image.png\" width=\"100\">\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "ZQ9giS3KIW-B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "QiIyzxRaIuwC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MCP QUBO驗算實例（含兩個分割）}\n",
        "\n",
        "## 例子回顧\n",
        "考慮一個四節點的加權圖，其邊集合及權重如下：\n",
        "$$E=\\{(1,2):1,\\; (1,3):2,\\; (2,3):3,\\; (2,4):2,\\; (3,4):1\\}.\n",
        "$$\n",
        "以二元變數 $x_i \\in \\{0,1\\}$ 表示節點所屬的集合。對於每個邊 $(i,j)$，其是否被切割可由指示函數表示為：\n",
        "$$\n",
        "\\mathbf{1}[x_i \\neq x_j] = x_i + x_j - 2x_i x_j.\n",
        "$$\n",
        "因此，Max-Cut 的最大化目標為：\n",
        "$$\n",
        "\\max \\;\\; \\sum_{(i,j)\\in E} w_{ij} \\bigl(x_i + x_j - 2x_i x_j \\bigr).\n",
        "$$\n",
        "將「最大化」轉換為「最小化」並寫成 QUBO，則每個邊 $(i,j)$ 權重 $w$ 的貢獻為：\n",
        "$$\n",
        "Q_{ii} \\mathrel{+}= -w, \\qquad\n",
        "Q_{jj} \\mathrel{+}= -w, \\qquad\n",
        "Q_{ij} \\mathrel{+}= 2w \\quad (i<j).\n",
        "$$\n",
        "在本例中得到 QUBO 矩陣(Q 矩陣)：\n",
        "$$\n",
        "Q=\\begin{bmatrix}\n",
        "-3 & 2 & 4 & 0 \\\\\n",
        "0  & -6 & 6 & 4 \\\\\n",
        "0  & 0 & -6 & 2 \\\\\n",
        "0  & 0 & 0 & -3\n",
        "\\end{bmatrix}.\n",
        "$$\n",
        "\n",
        "\n",
        "\n",
        "## 分割一：$x=(0,1,0,1)$ 的驗算\n",
        "### A. 直接用 cut 定義計算\n",
        "$$\n",
        "\\begin{aligned}\n",
        "(1,2): &\\; 0 \\neq 1 \\Rightarrow 1, \\\\\n",
        "(1,3): &\\; 0 = 0 \\Rightarrow 0, \\\\\n",
        "(2,3): &\\; 1 \\neq 0 \\Rightarrow 3, \\\\\n",
        "(2,4): &\\; 1 = 1 \\Rightarrow 0, \\\\\n",
        "(3,4): &\\; 0 \\neq 1 \\Rightarrow 1.\n",
        "\\end{aligned}\n",
        "\\qquad\\Rightarrow\\qquad\n",
        "\\text{cut}(x)=1+0+3+0+1=5.\n",
        "$$\n",
        "\n",
        "### B. 用QUBO目標函數計算\n",
        "$$\n",
        "f(x)=\\sum_i Q_{ii}x_i + \\sum_{i<j} Q_{ij}x_i x_j.\n",
        "$$\n",
        "對角項：\n",
        "$$\n",
        "(-3)\\cdot 0 + (-6)\\cdot 1 + (-6)\\cdot 0 + (-3)\\cdot 1 = -9.\n",
        "$$\n",
        "非對角項：\n",
        "$$\n",
        "2\\cdot 0\\cdot 1 + 4\\cdot 0\\cdot 0 + 0\\cdot 0\\cdot 1 + 6\\cdot 1\\cdot 0 + 4\\cdot 1\\cdot 1 + 2\\cdot 0\\cdot 1 = 4.\n",
        "$$\n",
        "因此 $f(x)=-9+4=-5$，與 $f(x)=-\\,\\text{cut}(x)$ 相符。\n",
        "\n",
        "## 分割二：$x=(0,0,1,1)$的驗算\n",
        "### A. 直接用cut定義計算\n",
        "$$\n",
        "\\begin{aligned}\n",
        "(1,2): &\\; 0 = 0 \\Rightarrow 0, \\\\\n",
        "(1,3): &\\; 0 \\neq 1 \\Rightarrow 2, \\\\\n",
        "(2,3): &\\; 0 \\neq 1 \\Rightarrow 3, \\\\\n",
        "(2,4): &\\; 0 \\neq 1 \\Rightarrow 2, \\\\\n",
        "(3,4): &\\; 1 = 1 \\Rightarrow 0.\n",
        "\\end{aligned}\n",
        "\\qquad\\Rightarrow\\qquad\n",
        "\\text{cut}(x)=0+2+3+2+0=7.\n",
        "$$\n",
        "\n",
        "### B. 用QUBO目標函數計算\n",
        "$$\n",
        "f(x)=\\sum_i Q_{ii}x_i + \\sum_{i<j} Q_{ij}x_i x_j.\n",
        "$$\n",
        "對角項：\n",
        "$$\n",
        "(-3)\\cdot 0 + (-6)\\cdot 0 + (-6)\\cdot 1 + (-3)\\cdot 1 = -9.\n",
        "$$\n",
        "非對角項：\n",
        "$$\n",
        "2\\cdot 0\\cdot 0 + 4\\cdot 0\\cdot 1 + 0\\cdot 0\\cdot 1 + 6\\cdot 0\\cdot 1 + 4\\cdot 0\\cdot 1 + 2\\cdot 1\\cdot 1 = 2.\n",
        "$$\n",
        "因此 $f(x)=-9+2=-7$，同樣滿足 $f(x)=-\\,\\text{cut}(x)$。\n",
        "\n",
        "## 結論\n",
        "上述兩個分割均驗證了在本例中 $f(x)=-\\,\\text{cut}(x)$（忽略常數項）的對應關係：  \n",
        "最大化 cut 值等價於最小化 QUBO 目標。"
      ],
      "metadata": {
        "id": "nyEHXQzcJdJm"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c976e819"
      },
      "source": [
        "### 最大割問題 (Max-Cut Problem) 的 QUBO 程式設計\n",
        "\n",
        "首先，我們需要導入（import）所需的套件：`networkx` 用於圖的表示（Graph Representation），`pyqubo` 用於QUBO模型建構，以及 `dwave.samplers` 中的 `SimulatedAnnealingSampler` 來進行求解。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "32ddc597",
        "outputId": "8626d0da-6ebd-4a14-a654-1b164b74ff18"
      },
      "source": [
        "import networkx as nx\n",
        "from pyqubo import Binary\n",
        "from dwave.samplers import SimulatedAnnealingSampler\n",
        "import numpy as np\n",
        "\n",
        "# 定義問題中給出的加權無向圖 (Weighted Undirected Graph)\n",
        "# 節點集合 V={0,1,2,3} (對應範例中的1,2,3,4)\n",
        "# 邊集合 E 及其權重如下：\n",
        "# E = {(1,2):1, (1,3):2, (2,3):3, (2,4):2, (3,4):1}\n",
        "\n",
        "G = nx.Graph()\n",
        "# 將邊和權重添加到圖中\n",
        "G.add_edge(0, 1, weight=1) # 節點 0 和 1 (原圖中的 1 和 2) 權重為 1\n",
        "G.add_edge(0, 2, weight=2) # 節點 0 和 2 (原圖中的 1 和 3) 權重為 2\n",
        "G.add_edge(1, 2, weight=3) # 節點 1 和 2 (原圖中的 2 和 3) 權重為 3\n",
        "G.add_edge(1, 3, weight=2) # 節點 1 和 3 (原圖中的 2 和 4) 權重為 2\n",
        "G.add_edge(2, 3, weight=1) # 節點 2 和 3 (原圖中的 3 和 4) 權重為 1\n",
        "#以上5行可用以下1行取代: add_weighted_edges_from的參數傳入包含(u, v, w)的清單，networkx會自動把第三個數字當成weight\n",
        "#G.add_weighted_edges_from([(0, 1, 1), (0, 2, 2), (1, 2, 3), (1, 3, 2), (2, 3, 1)])\n",
        "#也可以使用1行直接轉為networkx圖（自動將權重矩陣(weight matrix)數值帶入預設的weight屬性）\n",
        "#G = nx.from_numpy_array(matrix)\n",
        "nodes = G.nodes()\n",
        "print(\"圖的節點 (Graph Nodes):\", nodes)\n",
        "print(\"圖的邊 (Graph Edges) 及其權重:\", G.edges(data=True))\n"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "圖的節點 (Graph Nodes): [0, 1, 2, 3]\n",
            "圖的邊 (Graph Edges) 及其權重: [(0, 1, {'weight': 1}), (0, 2, {'weight': 2}), (1, 2, {'weight': 3}), (1, 3, {'weight': 2}), (2, 3, {'weight': 1})]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5e89de8d"
      },
      "source": [
        "### 建構 Max-Cut 問題的 QUBO 目標函數 (Objective Function)\n",
        "\n",
        "對於最大割問題，我們的目標是將節點集合 $V$ 劃分為兩個互不相交的子集合 $S$ 與 $V-S$，使得橫跨這兩個集合的邊的權重總和最大化。\n",
        "\n",
        "我們引入二元變數 $x_i \\in \\{0, 1\\}$，其中 $x_i=1$ 表示節點 $i$ 屬於集合 $S$，而 $x_i=0$ 表示節點 $i$ 屬於集合 $V-S$。\n",
        "\n",
        "當邊 $(i, j)$ 的兩端節點屬於不同的集合時（即 $x_i \\neq x_j$），該邊被切割。這個條件可以用 $x_i + x_j - 2x_i x_j$ 來表示。因此，最大化割值的目標函數為：\n",
        "\n",
        "$$\\max \\sum_{(i,j)\\in E} w_{ij} (x_i + x_j - 2x_i x_j)$$\n",
        "\n",
        "由於 QUBO 通常是最小化問題，我們將上述目標函數乘以 $-1$ 來轉換為最小化形式：\n",
        "\n",
        "$$\\min \\sum_{(i,j)\\in E} -w_{ij} (x_i + x_j - 2x_i x_j) = \\min \\sum_{(i,j)\\in E} (-w_{ij}x_i - w_{ij}x_j + 2w_{ij}x_i x_j)$$\n",
        "\n",
        "這個就是我們需要建構的 QUBO 漢米爾頓量（Hamiltonian）。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "e120c335",
        "outputId": "d40d86d9-6a61-44b8-e9b1-95092d5c12ad"
      },
      "source": [
        "# 為每個節點創建一個二元變數 (Binary Variable)\n",
        "# for i in nodes ==> 遍歷 nodes 集合(清單)，例如 nodes = [0, 1, 2, 3]\n",
        "# Binary(f'x{i}') ==> pyqubo套件中的函式，用來宣告二元變數\n",
        "# f'x{i}'==> Python 的 f-string 格式化字串，用來給模型中的變數取一個唯一的名稱（例如：當 i=0 時，變數名稱就是 'x0'；i=1 時為 'x1'）。\n",
        "# x = {i: ...} ==> 將每個節點i作為字典的鍵(key)，創建出來的二元變數作為值(value)，最後打包成一個名為x的字典。\n",
        "x = {i: Binary(f'x{i}') for i in nodes}\n",
        "\n",
        "# 初始化 QUBO 漢米爾頓量 (Hamiltonian) H\n",
        "H = 0\n",
        "\n",
        "# 根據 Max-Cut 的 QUBO 公式建構 H\n",
        "# 對於圖中的每一條邊 (i, j) 及其權重 weight;data: 該條邊的所有屬性字典 (例如 {'weight': 5, 'color': 'red'})\n",
        "# data=True 表示除了回傳邊的端點之外，還要一併取出邊的完整屬性字典\n",
        "for i, j, data in G.edges(data=True):\n",
        "    weight = data['weight'] #從邊的屬性字典 data 中，取出鍵（Key）為 'weight' 的數值，並賦值給變數 weight\n",
        "    H += -weight * x[i] - weight * x[j] + 2 * weight * x[i] * x[j]\n",
        "\n",
        "# 編譯漢米爾頓量 H 為 QUBO 模型 (Compile Hamiltonian to QUBO model)\n",
        "model = H.compile()\n",
        "\n",
        "# 提取 QUBO 矩陣 Q 和常數偏移量 offset\n",
        "Q, offset = model.to_qubo()\n",
        "\n",
        "print(\"生成的 QUBO 矩陣 (Generated QUBO Matrix Q):\")\n",
        "print(Q)\n",
        "print(f\"QUBO 偏移量 (QUBO Offset): {offset}\")\n"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "生成的 QUBO 矩陣 (Generated QUBO Matrix Q):\n",
            "{('x2', 'x3'): 2.0, ('x3', 'x1'): 4.0, ('x3', 'x3'): -3.0, ('x2', 'x1'): 6.0, ('x2', 'x0'): 4.0, ('x0', 'x0'): -3.0, ('x2', 'x2'): -6.0, ('x1', 'x0'): 2.0, ('x1', 'x1'): -6.0}\n",
            "QUBO 偏移量 (QUBO Offset): 0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6b2450ea"
      },
      "source": [
        "### 使用模擬退火（Simulated Annealing）求解 QUBO\n",
        "\n",
        "我們使用 D-Wave 的 `SimulatedAnnealingSampler` 來找到 QUBO 模型的最佳解。模擬退火是一種啟發式（Heuristic）演算法，它能夠在合理的計算時間內找到接近最佳的解（near-optimal solutions）。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "66061348",
        "outputId": "61200c61-cef2-4584-bd40-48ef9c032bfb"
      },
      "source": [
        "# 實例化 (Instantiate) 模擬退火求解器 (Sampler)\n",
        "sampler = SimulatedAnnealingSampler()\n",
        "\n",
        "# 進行取樣 (Sample)，嘗試多次以找到更好的解\n",
        "# num_reads 表示進行多少次獨立的模擬退火運行\n",
        "sampleset = sampler.sample_qubo(Q, num_reads=1000)\n",
        "\n",
        "# 取得能量最低的最佳樣本 (Best Sample with lowest energy)\n",
        "best_sample = sampleset.first.sample\n",
        "best_energy = sampleset.first.energy\n",
        "\n",
        "print(\"最佳節點分配解 (Best Node Assignment Solution):\")\n",
        "print(best_sample)\n",
        "print(f\"最低能量 (Minimum Energy, QUBO value): {best_energy}\")\n",
        "\n",
        "# 解釋結果：根據 x_i 的值將節點分成兩個集合\n",
        "set_S = [node for node, value in best_sample.items() if value == 1]\n",
        "set_V_minus_S = [node for node, value in best_sample.items() if value == 0]\n",
        "\n",
        "print(f\"\\n切割後的集合 S (Partition Set S): {set_S}\")\n",
        "print(f\"切割後的集合 V-S (Partition Set V-S): {set_V_minus_S}\")\n"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "最佳節點分配解 (Best Node Assignment Solution):\n",
            "{'x0': np.int8(0), 'x1': np.int8(0), 'x2': np.int8(1), 'x3': np.int8(1)}\n",
            "最低能量 (Minimum Energy, QUBO value): -7.0\n",
            "\n",
            "切割後的集合 S (Partition Set S): ['x2', 'x3']\n",
            "切割後的集合 V-S (Partition Set V-S): ['x0', 'x1']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "90ae0222"
      },
      "source": [
        "### 計算最大割值 (Max-Cut Value)\n",
        "\n",
        "我們將根據找到的最佳節點分配結果，計算實際的最大割值。割值是橫跨兩個集合的所有邊的權重總和。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "3b181d65",
        "outputId": "bc0c64f9-a8f7-4407-9b69-9128b85030c4"
      },
      "source": [
        "# 根據最佳樣本 (best_sample) 計算割值 (Cut Value)\n",
        "max_cut_value = 0\n",
        "for u, v, data in G.edges(data=True):\n",
        "    weight = data['weight']\n",
        "    # 檢查節點 u 和 v 是否在不同的集合中\n",
        "    # best_sample 中的鍵是 'x0', 'x1', ...，所以需要轉換\n",
        "    if best_sample[f'x{u}'] != best_sample[f'x{v}']:\n",
        "        max_cut_value += weight\n",
        "\n",
        "print(f\"根據最佳節點分配計算出的最大割值 (Calculated Max-Cut Value): {max_cut_value}\")\n",
        "\n",
        "# 驗證：QUBO 目標函數值應為負的最大割值\n",
        "# 因為我們最小化的是 -(Max-Cut Value) 的形式\n",
        "# 所以，Max-Cut Value = -(Minimum Energy)\n",
        "print(f\"從 QUBO 能量推導出的最大割值 (Max-Cut Value derived from QUBO energy): {-best_energy}\")\n",
        "\n",
        "# 請注意，由於 Simulated Annealing 是啟發式演算法，每次運行結果可能略有不同，但通常會找到最佳或接近最佳的解。\n"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "根據最佳節點分配計算出的最大割值 (Calculated Max-Cut Value): 7\n",
            "從 QUBO 能量推導出的最大割值 (Max-Cut Value derived from QUBO energy): 7.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# QUBO 與 Constraint 嵌入\n",
        "\n",
        "## 1. QUBO 的基本形式（無約束）\n",
        "QUBO (**Quadratic Unconstrained Binary Optimization**, 二次無約束二元最佳化) 的數學形式為：\n",
        "\n",
        "$$\n",
        "\\min_{x \\in \\{0,1\\}^n} f(x) \\;=\\; x^\\top Q x + c\n",
        "$$\n",
        "\n",
        "其中：\n",
        "- $x = (x_1, x_2, \\dots, x_n)^\\top \\in \\{0,1\\}^n$ 為二元變數向量。\n",
        "- $Q$ 為對稱矩陣(或上三角矩陣)。\n",
        "- $c$ 為常數項。\n",
        "\n",
        "👉 **重點**：「Unconstrained」代表 QUBO 本身沒有額外的限制條件，若要加上約束，必須透過懲罰項 (penalty term) 轉換進目標函數。\n",
        "\n",
        "---\n",
        "\n",
        "## 2. 在 QUBO 中嵌入約束的方法\n",
        "若有一個限制條件 $g(x) = 0$，可以在目標函數中加入懲罰項：\n",
        "\n",
        "$$\n",
        "P(x) = \\lambda \\cdot g(x)^2\n",
        "$$\n",
        "\n",
        "其中 $\\lambda$ 為懲罰權重，使得違反條件的解會有更高的能量，因而不會被取為最佳解。\n",
        "\n",
        "---\n",
        "\n",
        "## 3. 常見的約束類型\n",
        "\n",
        "### (a) One-hot constraint（唯一選擇約束）\n",
        "確保在一組二元變數中，**恰好一個取值為 1**：\n",
        "\n",
        "$$\n",
        "\\sum_{i=1}^n x_i = 1\n",
        "$$\n",
        "\n",
        "懲罰項：\n",
        "$$\n",
        "P(x) = \\lambda \\left(\\sum_{i=1}^n x_i - 1\\right)^2\n",
        "$$\n",
        "\n",
        "**例子**：在「城市選擇」問題中，假設有 3 個城市變數 $x_1, x_2, x_3$，必須選擇其中一個：\n",
        "$$\n",
        "(x_1 + x_2 + x_3 - 1)^2\n",
        "$$\n",
        "\n",
        "---\n",
        "\n",
        "### (b) At-most-one constraint（至多一個為 1）\n",
        "確保一組變數中，**最多只有一個變數等於 1**：\n",
        "\n",
        "$$\n",
        "\\sum_{i=1}^n x_i \\leq 1\n",
        "$$\n",
        "\n",
        "懲罰項：\n",
        "$$\n",
        "P(x) = \\lambda \\sum_{i<j} x_i x_j\n",
        "$$\n",
        "\n",
        "**例子**：排班問題：一名員工一天內不能同時上兩個班(如早班 $x_1$、晚班 $x_2$、大夜班 $x_3$）。\n",
        "\n",
        "---\n",
        "\n",
        "### (c) Capacity constraint（容量限制）\n",
        "常見於背包問題 (Knapsack Problem)：\n",
        "\n",
        "$$\n",
        "\\sum_{i=1}^n w_i x_i \\leq W\n",
        "$$\n",
        "\n",
        "懲罰項（若超過容量則懲罰）：\n",
        "$$\n",
        "P(x) = \\lambda \\left(\\max\\left(0, \\sum_{i=1}^n w_i x_i - W\\right)\\right)^2\n",
        "$$\n",
        "\n",
        "**例子**：有三個物品，重量 $w=(2,3,5)$，背包容量 $W=5$。若 $\\sum w_i x_i > 5$，就會有懲罰。\n",
        "\n",
        "---\n",
        "\n",
        "### (d) Exactly-k constraint（必須選 k 個）\n",
        "確保一組變數中，**恰好選 $k$ 個**：\n",
        "\n",
        "$$\n",
        "\\sum_{i=1}^n x_i = k\n",
        "$$\n",
        "\n",
        "懲罰項：\n",
        "$$\n",
        "P(x) = \\lambda \\left(\\sum_{i=1}^n x_i - k\\right)^2\n",
        "$$\n",
        "\n",
        "**例子**：從 5 個候選人中選 2 個：\n",
        "$$\n",
        "(x_1+x_2+x_3+x_4+x_5-2)^2\n",
        "$$\n",
        "\n",
        "---\n",
        "\n",
        "### (e) 一般等式約束\n",
        "若限制為：\n",
        "$$\n",
        "\\sum_{i=1}^n a_i x_i = b\n",
        "$$\n",
        "\n",
        "懲罰項：\n",
        "$$\n",
        "P(x) = \\lambda \\left(\\sum_{i=1}^n a_i x_i - b\\right)^2\n",
        "$$\n",
        "\n",
        "**例子**：分組問題，每組資源總量必須等於 10。\n",
        "\n",
        "---\n",
        "\n",
        "### (f) 一般不等式約束\n",
        "若限制為：\n",
        "$$\n",
        "\\sum_{i=1}^n a_i x_i \\leq b\n",
        "$$\n",
        "\n",
        "處理方式之一：引入鬆弛變數(slack variable)$s \\geq 0$，化為等式：\n",
        "$$\n",
        "\\sum_{i=1}^n a_i x_i + s = b\n",
        "$$\n",
        "\n",
        "再加上懲罰項。\n",
        "\n",
        "---\n",
        "\n",
        "### (g) 邏輯約束\n",
        "用布林代數嵌入：\n",
        "\n",
        "- **AND**: $z = x \\land y$  \n",
        "  $$P(x) = \\lambda (z - xy)^2$$\n",
        "\n",
        "- **OR**: $z = x \\lor y$  \n",
        "  $$P(x) = \\lambda (z - (x+y - xy))^2$$\n",
        "\n",
        "- **XOR**: $z = x \\oplus y$  \n",
        "  $$P(x) = \\lambda (z - (x+y - 2xy))^2$$\n",
        "\n",
        "**例子**：在電路設計或 SAT 問題中，常透過這些懲罰項將邏輯條件轉換成 QUBO。\n",
        "\n",
        "---\n",
        "\n",
        "## ✅ 總結\n",
        "- QUBO 本質上是「無約束」的，所有約束需透過懲罰項嵌入。  \n",
        "- 常見約束類型：One-hot、At-most-one、Exactly-k、容量限制、等式、不等式、邏輯限制。  \n",
        "- 核心思想：將違反限制的情況平方化，並以懲罰權重 $\\lambda$ 抑制，確保最佳解滿足約束。\n"
      ],
      "metadata": {
        "id": "8vpZdl85VzKS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Vertex Cover Problem\n",
        "&emsp;&emsp;圖的頂點覆蓋(vertex cover)是一個頂點的集合，能夠覆蓋圖中的每一個邊，也就是使圖中的每一個邊都至少連結該集合中的一個頂點。尋找最小的頂點覆蓋的問題稱為頂點覆蓋問題（vertex cover problem, VCP），它是一個NP完全(NPC)問題。\n",
        "\n",
        "&emsp;&emsp;假設有一無向圖 $G = (V, E)$，其中 $V$ 為頂點集合，$E$ 為邊集合。頂點覆蓋是指從 $V$ 中選出一個子集 $C \\subseteq V$，使得圖中每個邊 $e = (u, v)$ 至少有一個端點屬於 $C$。也就是說，對於所有邊 $(u,v) \\in E$，必有 $u \\in C$ 或 $v \\in C$（或兩者皆成立）。\n",
        "\n",
        "&emsp;&emsp;下圖是兩個頂點覆蓋問題的範例，紅點表示對於該圖來說的某個頂點覆蓋集合。 QUBO 的目標是求使用最少個頂點形成一個頂點覆蓋集。\n",
        "\n",
        "![Vertex-cover.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   width="200"
   height="60"
   id="svg4786"
   sodipodi:version="0.32"
   inkscape:version="0.46"
   version="1.0"
   sodipodi:docname="vertex-cover.svg"
   inkscape:output_extension="org.inkscape.output.svg.inkscape">
  <defs
     id="defs4788" />
  <sodipodi:namedview
     id="base"
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1.0"
     gridtolerance="10000"
     guidetolerance="10"
     objecttolerance="10"
     inkscape:pageopacity="0.0"
     inkscape:pageshadow="2"
     inkscape:zoom="1.979899"
     inkscape:cx="139.43394"
     inkscape:cy="83.300943"
     inkscape:document-units="px"
     inkscape:current-layer="layer1"
     showgrid="false"
     inkscape:window-width="964"
     inkscape:window-height="844"
     inkscape:window-x="0"
     inkscape:window-y="0" />
  <metadata
     id="metadata4791">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <g
     inkscape:label="Layer 1"
     inkscape:groupmode="layer"
     id="layer1"
     transform="translate(-517.92857,-709.21932)">
    <path
       id="path3600"
       d="M 531.92857,744.21932 L 551.92857,729.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       sodipodi:nodetypes="cc"
       id="path3602"
       d="M 551.92857,729.21932 L 581.92857,719.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       id="path3604"
       d="M 531.92857,744.21932 L 551.92857,759.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       id="path3606"
       d="M 551.92857,729.21932 L 551.92857,759.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       sodipodi:nodetypes="cc"
       id="path3608"
       d="M 551.92857,729.21932 L 581.92857,739.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       sodipodi:nodetypes="cc"
       id="path3610"
       d="M 551.92857,729.21932 L 576.92857,759.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
       d="M 626.92857,744.21932 L 646.92857,729.21932"
       id="path3612" />
    <path
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
       d="M 626.92857,744.21932 L 646.92857,759.21932"
       id="path3614" />
    <path
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
       d="M 646.92857,729.21932 L 646.92857,759.21932"
       id="path3616" />
    <path
       id="path3618"
       d="M 646.92857,729.21932 L 676.92857,729.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       id="path3620"
       d="M 646.92857,759.21932 L 676.92857,759.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       id="path3622"
       d="M 676.92857,729.21932 L 706.92857,729.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       id="path3624"
       d="M 676.92857,729.21932 L 676.92857,759.21932"
       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <path
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z"
       sodipodi:ry="5"
       sodipodi:rx="5"
       sodipodi:cy="437.36218"
       sodipodi:cx="210"
       id="path3638"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       sodipodi:type="arc"
       transform="translate(341.92857,291.85714)" />
    <path
       transform="translate(341.92857,321.85714)"
       sodipodi:type="arc"
       style="opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       id="path3640"
       sodipodi:cx="210"
       sodipodi:cy="437.36218"
       sodipodi:rx="5"
       sodipodi:ry="5"
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z" />
    <path
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z"
       sodipodi:ry="5"
       sodipodi:rx="5"
       sodipodi:cy="437.36218"
       sodipodi:cx="210"
       id="path3642"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       sodipodi:type="arc"
       transform="translate(321.92857,306.85714)" />
    <path
       transform="translate(366.92857,321.85714)"
       sodipodi:type="arc"
       style="opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       id="path3644"
       sodipodi:cx="210"
       sodipodi:cy="437.36218"
       sodipodi:rx="5"
       sodipodi:ry="5"
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z" />
    <path
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z"
       sodipodi:ry="5"
       sodipodi:rx="5"
       sodipodi:cy="437.36218"
       sodipodi:cx="210"
       id="path3646"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       sodipodi:type="arc"
       transform="translate(371.92857,301.85714)" />
    <path
       transform="translate(371.92857,281.85714)"
       sodipodi:type="arc"
       style="opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       id="path3648"
       sodipodi:cx="210"
       sodipodi:cy="437.36218"
       sodipodi:rx="5"
       sodipodi:ry="5"
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z" />
    <path
       transform="translate(436.92857,291.85714)"
       sodipodi:type="arc"
       style="opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       id="path3650"
       sodipodi:cx="210"
       sodipodi:cy="437.36218"
       sodipodi:rx="5"
       sodipodi:ry="5"
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z" />
    <path
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z"
       sodipodi:ry="5"
       sodipodi:rx="5"
       sodipodi:cy="437.36218"
       sodipodi:cx="210"
       id="path3652"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"
       sodipodi:type="arc"
       transform="translate(436.92857,321.85714)" />
    <path
       transform="translate(416.92857,306.85714)"
       sodipodi:type="arc"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       id="path3654"
       sodipodi:cx="210"
       sodipodi:cy="437.36218"
       sodipodi:rx="5"
       sodipodi:ry="5"
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z" />
    <path
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z"
       sodipodi:ry="5"
       sodipodi:rx="5"
       sodipodi:cy="437.36218"
       sodipodi:cx="210"
       id="path3656"
       style="opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"
       sodipodi:type="arc"
       transform="translate(466.92857,321.85714)" />
    <path
       transform="translate(466.92857,291.85714)"
       sodipodi:type="arc"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"
       id="path3658"
       sodipodi:cx="210"
       sodipodi:cy="437.36218"
       sodipodi:rx="5"
       sodipodi:ry="5"
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z" />
    <path
       d="M 215,437.36218 A 5,5 0 1 1 205,437.36218 A 5,5 0 1 1 215,437.36218 z"
       sodipodi:ry="5"
       sodipodi:rx="5"
       sodipodi:cy="437.36218"
       sodipodi:cx="210"
       id="path3660"
       style="opacity:1;fill:#d40000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate;color:#000000"
       sodipodi:type="arc"
       transform="translate(496.92857,291.85714)" />
  </g>
</svg>
)\n",
        "# Homework\n",
        "本次作業請大家利用量子退火求解頂點覆蓋問題。程式至少能夠解決 keller4.mis 資料集中的最小覆蓋問題，其中的圖包含160個頂點。\n",
        "\n",
        "報告書應包含：\n",
        "1. 問題說明\n",
        "2. QUBO 公式\n",
        "3. 實驗結果\n"
      ],
      "metadata": {
        "id": "ZrKMATd2WpTF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 資料集\n",
        "資料的形式為 Edge List，以 keller4.mis 為例，部分資料如下，第一行是 `p edge 點的數量 邊的數量`，接著每一行描述一個邊所連接的兩個頂點 `e 頂點 頂點`。\n",
        "\n",
        "keller4.mis 資料集：\n",
        "```\n",
        "p edge 171 5100                                   \n",
        "e 1 2\n",
        "e 1 3\n",
        "e 1 4\n",
        "e 1 5\n",
        "e 1 6\n",
        "e 1 7\n",
        "e 1 9\n",
        "e 1 10\n",
        "e 1 11\n",
        "e 1 18\n",
        "e 1 28\n",
        "e 1 29\n",
        "e 1 31\n",
        "e 1 32\n",
        ".\n",
        ".\n",
        ".\n",
        "```\n",
        "\n",
        "下列程式碼將呈現如何讀入資料集，並且建構該圖的 networkx Grahp 物件。\n",
        "networkx 是一個 python 套件，主要用來分析圖、網路等。我們將使用這個套件來儲存圖。\n",
        "Network x: https://networkx.org/"
      ],
      "metadata": {
        "id": "8dA45lSvWrep"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "from pyqubo import Binary\n",
        "from dwave.samplers import SimulatedAnnealingSampler\n",
        "import numpy as np\n",
        "\n",
        "# 假設圖 G 已經從 keller4.mis 資料集載入 (assuming graph G is already loaded from keller4.mis dataset)\n",
        "# 如果 G 尚未定義，請確保先執行讀取 keller4.mis 的程式碼單元 (-d00SydUXHEV)。\n",
        "\n",
        "# ==================================================================\n",
        "# 1. 問題說明與 QUBO 公式 (Problem Description and QUBO Formulation)\n",
        "# ==================================================================\n",
        "\n",
        "# 頂點覆蓋問題 (Vertex Cover Problem, VCP) 的目標是找到一個最小的頂點子集 (subset of vertices)，\n",
        "# 使得圖中所有的邊 (edges) 都至少有一個端點 (endpoint) 在這個子集內。VCP 是一個 NP-完全 (NP-Complete) 問題。\n",
        "\n",
        "# QUBO 建模 (QUBO Modeling):\n",
        "# 定義二元變數 (Binary Variable) x_i：\n",
        "# x_i = 1 如果節點 i 在頂點覆蓋集中 (vertex i is in the cover)\n",
        "# x_i = 0 如果節點 i 不在頂點覆蓋集中 (vertex i is not in the cover)\n",
        "\n",
        "# 目標函數 (Objective Function)：最小化選擇的頂點數量 (minimize the number of selected vertices)\n",
        "# H_objective = sum(x_i for all i in V)\n",
        "\n",
        "# 約束條件 (Constraint)：對於圖中所有的邊 (u, v)，至少一個端點必須在覆蓋集中。\n",
        "# 這表示我們不能有 x_u = 0 且 x_v = 0 的情況。\n",
        "# 這個約束可以透過懲罰項 (penalty term) 來實施：如果 x_u = 0 且 x_v = 0，則懲罰項為 1，否則為 0。\n",
        "# H_constraint = sum((1 - x_u) * (1 - x_v) for all (u,v) in E)\n",
        "\n",
        "# 完整的 QUBO 漢米爾頓量 (Hamiltonian) H：\n",
        "# H = A * H_objective + B * H_constraint\n",
        "# 其中 A 和 B 是正的權重係數 (positive weight coefficients)。\n",
        "# A 用來鼓勵選擇較少的頂點，B 用來強制滿足覆蓋條件。\n",
        "# B 通常會設定得比 A 大，以確保約束被優先滿足。一個常見的策略是 B > A * 最大節點度 (max degree).\n",
        "# 在此範例中，我們設定 A=1，B=2（一個常用且足夠大的值）\n",
        "\n",
        "nodes = G.nodes()\n",
        "\n",
        "# 為每個節點創建一個二元變數 (Create binary variables for each node)\n",
        "x = {node: Binary(f'x{node}') for node in nodes}\n",
        "\n",
        "# 初始化 QUBO 漢米爾頓量 (Initialize QUBO Hamiltonian) H\n",
        "H = 0\n",
        "\n",
        "# 設定權重係數 (Set weight coefficients)\n",
        "A = 1  # 最小化頂點數的權重 (weight for minimizing vertex count)\n",
        "B = 2  # 懲罰未覆蓋邊的權重 (penalty weight for uncovered edges)\n",
        "\n",
        "# 添加目標項：最小化頂點覆蓋集的大小 (Add objective term: minimize the size of the vertex cover)\n",
        "for node in nodes:\n",
        "    H += A * x[node]\n",
        "\n",
        "# 添加約束項：確保每條邊都被覆蓋 (Add constraint term: ensure every edge is covered)\n",
        "for u, v in G.edges():\n",
        "    # 如果 (1-x[u]) * (1-x[v]) == 1，表示 u 和 v 都不在覆蓋集中，該邊未被覆蓋，則施加懲罰\n",
        "    H += B * (1 - x[u]) * (1 - x[v])\n",
        "\n",
        "# ==================================================================\n",
        "# 2. 編譯 QUBO 模型並求解 (Compile QUBO Model and Solve)\n",
        "# ==================================================================\n",
        "\n",
        "# 編譯漢米爾頓量 H 為 PyQUBO 模型 (Compile Hamiltonian H to PyQUBO model)\n",
        "model = H.compile()\n",
        "\n",
        "# 提取 QUBO 矩陣 Q 和常數偏移量 offset (Extract QUBO matrix Q and offset)\n",
        "Q, offset = model.to_qubo()\n",
        "\n",
        "print(\"生成的 QUBO 矩陣 Q (Generated QUBO Matrix Q):\")\n",
        "# 注意：對於大型圖（如 keller4.mis），Q 會非常大，不建議直接印出。\n",
        "# print(Q)\n",
        "print(f\"QUBO 矩陣 Q 的大小 (Size of QUBO Matrix Q): {len(Q)} 鍵值對 (key-value pairs)\")\n",
        "print(f\"QUBO 偏移量 (QUBO Offset): {offset}\")\n",
        "\n",
        "# 實例化模擬退火求解器 (Instantiate Simulated Annealing Sampler)\n",
        "sampler = SimulatedAnnealingSampler()\n",
        "\n",
        "# 進行取樣 (Sample)，嘗試多次以找到更好的解\n",
        "# num_reads 表示進行多少次獨立的模擬退火運行\n",
        "print(\"\\n開始進行模擬退火取樣 (Starting Simulated Annealing sampling)... 這可能需要一些時間。\")\n",
        "sampleset = sampler.sample_qubo(Q, num_reads=100)\n",
        "\n",
        "# 取得能量最低的最佳樣本 (Get the best sample with the lowest energy)\n",
        "best_sample = sampleset.first.sample\n",
        "best_energy = sampleset.first.energy\n",
        "\n",
        "print(\"\\n最佳節點分配解 (Best Node Assignment Solution):\")\n",
        "# 對於大型圖，也不建議直接印出所有 x 值\n",
        "# print(best_sample)\n",
        "print(f\"最低能量 (Minimum Energy, QUBO value): {best_energy}\")\n",
        "\n",
        "# ==================================================================\n",
        "# 3. 解釋結果 (Interpret Results)\n",
        "# ==================================================================\n",
        "\n",
        "# 從最佳樣本中找出在覆蓋集中的節點 (Identify nodes in the cover from the best sample)\n",
        "vertex_cover = [node for node, value in best_sample.items() if value == 1]\n",
        "\n",
        "print(f\"\\n找到的頂點覆蓋集 (Found Vertex Cover): {vertex_cover}\")\n",
        "print(f\"頂點覆蓋集的大小 (Size of Vertex Cover): {len(vertex_cover)}\")\n",
        "\n",
        "# 驗證解是否滿足約束：檢查是否有邊未被覆蓋 (Verify if the solution satisfies the constraints)\n",
        "all_edges_covered = True\n",
        "uncovered_edges = []\n",
        "for u, v in G.edges():\n",
        "    # 如果 u 和 v 都不在覆蓋集中，則該邊未被覆蓋\n",
        "    if best_sample[f'x{u}'] == 0 and best_sample[f'x{v}'] == 0:\n",
        "        all_edges_covered = False\n",
        "        uncovered_edges.append((u, v))\n",
        "\n",
        "if all_edges_covered:\n",
        "    print(\"所有邊皆被覆蓋 (All edges are covered)！約束條件滿足 (Constraints satisfied).\")\n",
        "else:\n",
        "    print(f\"警告：有 {len(uncovered_edges)} 條邊未被覆蓋 (Warning: {len(uncovered_edges)} edges are not covered). 可能需要調整懲罰權重 B (May need to adjust penalty weight B).\")\n",
        "    # print(f\"未覆蓋的邊: {uncovered_edges}\")\n",
        "\n",
        "# 對於 keller4.mis，已知最小頂點覆蓋集大小為 160 (For keller4.mis, the minimum vertex cover size is known to be 160).\n",
        "# 請注意，模擬退火是一種啟發式演算法 (heuristic algorithm)，\n",
        "# 對於大型問題不保證找到絕對的最佳解 (absolute optimal solution)，\n",
        "# 但會提供一個近似最佳解 (near-optimal solution)。\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "LZOPfWevXk0r",
        "outputId": "6db03e97-44b3-44e6-e8dd-12960f43544b"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "生成的 QUBO 矩陣 Q (Generated QUBO Matrix Q):\n",
            "QUBO 矩陣 Q 的大小 (Size of QUBO Matrix Q): 9 鍵值對 (key-value pairs)\n",
            "QUBO 偏移量 (QUBO Offset): 10.0\n",
            "\n",
            "開始進行模擬退火取樣 (Starting Simulated Annealing sampling)... 這可能需要一些時間。\n",
            "\n",
            "最佳節點分配解 (Best Node Assignment Solution):\n",
            "最低能量 (Minimum Energy, QUBO value): -8.0\n",
            "\n",
            "找到的頂點覆蓋集 (Found Vertex Cover): ['x1', 'x2']\n",
            "頂點覆蓋集的大小 (Size of Vertex Cover): 2\n",
            "所有邊皆被覆蓋 (All edges are covered)！約束條件滿足 (Constraints satisfied).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "以下為讀入 .mis 或 .clq 等 DIMACS 格式資料集的程式範例:"
      ],
      "metadata": {
        "id": "e5-rodOgSBrK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "#讀取data\n",
        "path = f'/content/drive/MyDrive/Colab Notebooks/VertexCover/data/keller4.mis' # 資料集路徑\n",
        "instance = [] # 宣告一個空串列，將每個邊存入 instance 中\n",
        "with open(path) as f: # 讀取資料集的檔案\n",
        "    for line in f.readlines():\n",
        "        first_node = line.split()[1] # 將每個邊連接的兩個頂點拿出來，命名為 first_node 與 second_node\n",
        "        second_node = line.split()[2]\n",
        "        if len(instance) != 0:\n",
        "          first_node = int(first_node)\n",
        "          second_node = int(second_node)\n",
        "        edge = (first_node,second_node) # 將一個邊組成一個 tuple 並且存入 instance 中\n",
        "        instance.append(edge)\n",
        "instance.pop(0) # 將第一行移除，因為第一行只有描述這張圖的點數和邊數，並不是描述邊\n",
        "\n",
        "G = nx.Graph() # 建立一個圖物件，命名為 G\n",
        "G.add_edges_from(instance) # 讓 G 根據 instance 的資料建構圖"
      ],
      "metadata": {
        "id": "-d00SydUXHEV",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "collapsed": true,
        "outputId": "5d53b906-9b4a-4057-b2ad-803f82dca2f6"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "[Errno 2] No such file or directory: '/content/drive/MyDrive/Colab Notebooks/VertexCover/data/keller4.mis'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m/tmp/ipykernel_809/2754324075.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mpath\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf'/content/drive/MyDrive/Colab Notebooks/VertexCover/data/keller4.mis'\u001b[0m \u001b[0;31m# 資料集路徑\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0minstance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# 宣告一個空串列，將每個邊存入 instance 中\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# 讀取資料集的檔案\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadlines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0mfirst_node\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# 將每個邊連接的兩個頂點拿出來，命名為 first_node 與 second_node\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/content/drive/MyDrive/Colab Notebooks/VertexCover/data/keller4.mis'"
          ]
        }
      ]
    }
  ]
}