{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "f7d9993f",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Iskay 양자 최적화기 - Kipu Quantum의 Qiskit 함수\"\n",
        "description: \"키푸 퀀텀의 Iskay 퀀텀 최적화기를 통해 최적화 문제를 효율적으로 해결하세요. IBM 에서 이용 가능합니다. Qiskit Functions Catalog\"\n",
        "---\n",
        "\n",
        "{/* cspell:ignore Kipu, DCQO, QUBO, HUBO, counterdiabatic, Iskay, bitflips, Cadavid, Chandarana */}\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dde95705",
      "metadata": {},
      "source": [
        "<span id=\"iskay-quantum-optimizer---a-qiskit-function-by-kipu-quantum\" />\n",
        "\n",
        "# Iskay 양자 최적화기 - Kipu Quantum의 Qiskit 함수\n",
        "\n",
        "*[API 참조](/docs/api/functions/kipu-optimization) 보기*\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "61da1dd5",
      "metadata": {
        "tags": [
          "version-info"
        ]
      },
      "source": [
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c60ba821",
      "metadata": {},
      "source": [
        "<Admonition type=\"note\" title=\"참고\">\n",
        "  * 키스킷 기능은 IBM 퀀텀 프리미엄 요금제, 플렉스 요금제 및 온프레미스( IBM 퀀텀 플랫폼 API를 통해) 요금제 사용자에게만 제공되는 실험적 기능입니다. 프리뷰 릴리스 상태이며 변경될 수 있습니다.\n",
        "</Admonition>\n",
        "\n",
        "<span id=\"overview\" />\n",
        "\n",
        "## 개요\n",
        "\n",
        "Kipu Quantum의 Iskay 퀀텀 옵티마이저를 사용하면 IBM® 퀀텀 컴퓨터를 사용하여 복잡한 최적화 문제를 해결할 수 있습니다. 이 솔버는 목적 함수만 입력하면 되는 Kipu의 최첨단 [bf-DCQO 알고리즘을](https://doi.org/10.48550/arXiv.2409.04477) 활용하여 자동으로 문제 해결책을 제공합니다. 최대 156개의 큐비트와 관련된 최적화 문제를 처리할 수 있어 IBM 양자 디바이스의 모든 큐비트를 사용할 수 있습니다. 옵티마이저는 클래식 변수와 큐비트 간의 1-to-1 매핑을 사용하여 최대 156개의 이진 변수로 최적화 문제를 해결할 수 있습니다.\n",
        "\n",
        "옵티마이저를 사용하면 제약이 없는 이진 최적화 문제를 해결할 수 있습니다. 일반적으로 사용되는 QUBO(이차 제약 없는 이진 최적화) 공식 외에도 고차(HUBO) 최적화 문제도 지원합니다. 솔버는 비변형 양자 알고리즘을 사용하여 대부분의 계산을 양자 디바이스에서 수행합니다.\n",
        "\n",
        "다음은 사용된 알고리즘에 대한 자세한 내용과 함수 사용 방법에 대한 간단한 가이드, 그리고 다양한 크기와 복잡성의 다양한 문제 사례에 대한 벤치마킹 결과를 제공합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5f761442",
      "metadata": {},
      "source": [
        "<span id=\"description\" />\n",
        "\n",
        "## 설명\n",
        "\n",
        "옵티마이저는 바로 사용할 수 있는 최첨단 양자 최적화 알고리즘을 구현한 것입니다. 양자 하드웨어에서 고도로 압축된 양자 회로를 실행하여 최적화 문제를 해결합니다. 이러한 압축은 양자 시스템의 기본 시간 진화에 반역학 용어를 도입함으로써 이루어집니다. 알고리즘은 하드웨어 실행을 여러 번 반복하여 최종 솔루션을 얻고 이를 후처리와 결합합니다. 이러한 단계는 최적화 도구의 워크플로에 원활하게 통합되어 자동으로 실행됩니다.\n",
        "\n",
        "<span id=\"how-does-the-quantum-optimizer-work\" />\n",
        "\n",
        "### 양자 최적화기는 어떻게 작동하나요?\n",
        "\n",
        "이 섹션에서는 구현된 bf-DCQO 알고리즘의 기본 사항을 설명합니다. 해당 알고리즘에 대한 소개는 [Qiskit YouTube](https://www.youtube.com/watch?v=33QmsXhIlpU\\&t=1223s) 채널에서도 확인할 수 있습니다.\n",
        "\n",
        "이 알고리즘은 시간에 따라 변형되는 양자 시스템의 시간 진화를 기반으로 하며, 문제 해결은 진화가 끝날 때 양자 시스템의 기저 상태로 인코딩됩니다. 단열 [정리에](https://en.wikipedia.org/wiki/Adiabatic_theorem) 따르면, 시스템이 접지 상태를 유지하려면 이 진화 속도가 느려야 합니다. 이러한 진화를 디지털화하는 것이 바로 디지털화된 양자 단열 계산(DQA)과 악명 높은 QAOA 알고리즘의 기반입니다. 그러나 필요한 느린 진화는 회로 깊이가 증가하기 때문에 문제 크기가 커지는 경우에는 불가능합니다. 역당뇨 프로토콜을 사용하면 짧은 진화 시간 동안 발생하는 원치 않는 흥분을 억제하면서 지상 상태를 유지할 수 있습니다. 여기서 이 짧은 진화 시간을 디지털화하면 더 짧은 깊이와 더 적은 수의 얽힘 게이트를 가진 양자 회로가 생성됩니다.\n",
        "\n",
        "Bf-DCQO 알고리즘의 회로는 일반적으로 DQA보다 최대 10배 적은 수의 얽힘 게이트를 사용하며, 표준 QAOA 구현보다 3\\~4배 적은 수의 얽힘 게이트를 사용합니다. 게이트 수가 적기 때문에 하드웨어에서 회로를 실행하는 동안 발생하는 오류가 적습니다. 따라서 최적화 도구는 오류 억제 또는 오류 완화와 같은 기술을 사용할 필요가 없습니다. 향후 버전에서 이를 구현하면 솔루션 품질을 더욱 향상시킬 수 있습니다.\n",
        "\n",
        "Bf-DCQO 알고리즘은 반복을 사용하지만 가변적이지 않습니다. 알고리즘을 반복할 때마다 상태의 분포를 측정합니다. 얻은 분포는 소위 바이어스 필드를 계산하는 데 사용됩니다. 바이어스 필드를 사용하면 이전에 찾은 해에 가까운 에너지 상태에서 다음 반복을 시작할 수 있습니다. 이러한 방식으로 알고리즘은 반복할 때마다 더 낮은 에너지의 솔루션으로 이동합니다. 일반적으로 약 10회의 반복으로 솔루션에 수렴하는 데 충분하며, 총 반복 횟수는 약 100회 정도인 변형 알고리즘보다 훨씬 적습니다.\n",
        "\n",
        "옵티마이저는 bf-DCQO 알고리즘과 기존 포스트 프로세싱을 결합합니다. 상태 분포를 측정한 후 로컬 검색이 수행됩니다. 로컬 검색 중에 측정된 솔루션의 비트가 무작위로 뒤집힙니다. 플립 후 새 비트스트링의 에너지가 평가됩니다. 에너지가 더 낮으면 비트스트링이 새 솔루션으로 유지됩니다. 로컬 검색은 큐비트 수에 따라 선형적으로만 확장되므로 계산 비용이 저렴합니다. 후처리는 로컬 비트플립을 수정하므로 하드웨어 결함 및 판독 오류로 인해 발생하는 비트플립 오류를 보정합니다.\n",
        "\n",
        "<span id=\"workflow\" />\n",
        "\n",
        "### 워크플로우\n",
        "\n",
        "퀀텀 옵티마이저의 워크플로 도식은 다음과 같습니다.\n",
        "\n",
        "![워크플로](https://quantum.cloud.ibm.com/docs/images/guides/kipu-optimization/workflow.svg \"퀀텀 옵티마이저의 워크플로\")\n",
        "\n",
        "퀀텀 옵티마이저를 사용하면 퀀텀 하드웨어의 최적화 문제를 다음과 같이 해결할 수 있습니다\n",
        "\n",
        "* 문제의 객관적 함수 공식화\n",
        "* 키스킷 함수를 통해 옵티마이저에 액세스하기\n",
        "* 최적화 도구를 실행하고 결과를 수집합니다\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b34fe075",
      "metadata": {},
      "source": [
        "<span id=\"benchmarks\" />\n",
        "\n",
        "## 벤치마크\n",
        "\n",
        "<Admonition type=\"caution\" title=\"면책사항\">\n",
        "  성능은 문제 인스턴스와 그 후의 처리 단계 모두에 따라 달라질 수 있습니다. 경우에 따라서는, 동등한 후처리를 거친 후 고전적 샘플과 양자 생성 샘플이 유사한 최종 솔루션 품질을 달성할 수도 있다. 따라서 평가 시에는 최적화 워크플로우 전체를 고려해야 합니다.\n",
        "</Admonition>\n",
        "\n",
        "아래 벤치마크 지표는 옵티마이저가 최대 156개의 큐비트와 관련된 문제를 효과적으로 해결하고 다양한 문제 유형에서 옵티마이저의 정확성과 확장성에 대한 일반적인 개요를 보여줍니다. 실제 성능 지표는 변수 수, 목적 함수의 항의 밀도 및 지역성, 다항식 순서와 같은 특정 문제 특성에 따라 달라질 수 있다는 점에 유의하세요.\n",
        "\n",
        "다음 표에는 다음과 같이 정의된 지표인 AR(근사화 비율)이 포함되어 있습니다:\n",
        "\n",
        "$$\n",
        "AR = \\frac{C^{*} - C_\\textrm{max}}{C_{\\textrm{min}} - C_{\\textrm{max}}},\n",
        "$$\n",
        "\n",
        "여기서 $C$ 은 목적 함수, $C_{\\textrm{min}}$, $C_{\\textrm{max}}$ 은 각각 최소값과 최대값, $C^{*}$ 은 찾은 최적의 해의 비용입니다. 따라서 AR=100% 은 문제의 기저 상태를 얻었음을 의미합니다.\n",
        "\n",
        "| 예             |   큐비트 수   | 근사 비율 | 총시간(초) | 런타임 사용량(초) | 총 촬영 횟수 |  반복 수  |\n",
        "| ------------- | :-------: | :---: | :----: | :--------: | :-----: | :----: |\n",
        "| 가중치 없음 MaxCut |     28    | 100%로 |   180  |  6시간에서 30분 |   30k   |    5   |\n",
        "| 가중치 없음 MaxCut | 6시간에서 30분 | 100%로 |   180  |  6시간에서 30분 |   30k   |    5   |\n",
        "| 가중치 없음 MaxCut |     32    | 100%로 |   180  |  6시간에서 30분 |   30k   |    5   |\n",
        "| 가중치 없음 MaxCut |     10    | 100%로 |   480  |     60     |   90k   |    9   |\n",
        "| 가중치 없음 MaxCut |    100    | 100%로 |   330  |     60     |   60k   |    6   |\n",
        "| 가중치 없음 MaxCut |    120    | 100%로 |   370  |     60     |   60k   |    6   |\n",
        "| HUBO 1        |    156    | 100%로 |   600  |     70     |   100k  | 1,000만 |\n",
        "| HUBO 2        |    156    | 100%로 |   600  |     70     |   100k  | 1,000만 |\n",
        "\n",
        "* 28, 30, 32 큐비트의 MaxCut 인스턴스는 ibm\\_sherbrooke에서 실행되었습니다. 80, 100, 120 인스턴스는 Heron r2 프로세서에서 실행되었습니다.\n",
        "* HUBO 인스턴스도 Heron r2 프로세서에서 실행되었습니다.\n",
        "\n",
        "모든 벤치마크 인스턴스는 GitHub 에서 액세스할 수 있습니다( [Kipu 벤치마크 인스턴스](https://github.com/Kipu-Quantum-GmbH/benchmark-instances) 참조). 이러한 인스턴스를 실행하는 예제는 [예제 3: 벤치마크 인스턴스에서](#example-3-benchmark-instances) 확인할 수 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "73390a19",
      "metadata": {},
      "source": [
        "<span id=\"get-started\" />\n",
        "\n",
        "## 시작하기\n",
        "\n",
        "이 문서에서는 Iskay 양자 최적화기를 사용하는 단계를 살펴보겠습니다. 이 과정에서 우리는 카탈로그에서 함수를 불러오는 방법과 여러분의 문제를 유효한 입력으로 변환하는 방법을 신속하게 보여줄 것이며, 동시에 다양한 선택적 매개변수를 실험해볼 수 있는 방법을 함께 제시할 것입니다.\n",
        "\n",
        "더 자세한 예시를 보려면 튜토리얼 ['Kipu Quantum의 Iskay Quantum Optimizer로 시장 분할 문제 해결하기'를](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer) 참고하시기 바랍니다. 이 튜토리얼에서는 Iskay Solver를 활용해 시장 분할 문제를 해결하는 전체 과정을 단계별로 설명합니다. 시장 분할 문제는 실제 자원 배분 과제에서 시장이 균형 잡힌 판매 지역으로 분할되어 정확한 수요 목표를 충족해야 하는 상황을 나타냅니다.\n",
        "\n",
        "[IBM 퀀텀 플랫폼 대시보드에](http://quantum.cloud.ibm.com/) 있는 API 키를 사용하여 인증하고 다음과 같이 키스킷 기능을 선택합니다:\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e5cd4ac8",
      "metadata": {},
      "source": [
        "<Admonition type=\"note\">\n",
        "  다음 코드는 사용자가 인증 정보를 저장해 두었다고 가정합니다. 아직 진행하지 않으셨다면, [‘ IBM Cloud 계정 저장](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) ’에 있는 지침에 따라 API 키로 인증을 진행해 주세요.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "68d3ecea-f7e3-4b4b-b299-1670abc72415",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[QiskitFunction(qunova/hivqe-chemistry),\n",
              " QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),\n",
              " QiskitFunction(algorithmiq/tem),\n",
              " QiskitFunction(qedma/qesem),\n",
              " QiskitFunction(multiverse/singularity),\n",
              " QiskitFunction(ibm/circuit-function),\n",
              " QiskitFunction(q-ctrl/optimization-solver),\n",
              " QiskitFunction(colibritd/quick-pde),\n",
              " QiskitFunction(q-ctrl/performance-management),\n",
              " QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
        "\n",
        "catalog = QiskitFunctionsCatalog(\n",
        "    channel=\"ibm_quantum_platform\",\n",
        "    instance=\"INSTANCE_CRN\",\n",
        "    # For `token`, use the 44-character API_KEY you created\n",
        "    # and saved from the IBM Quantum Platform Home dashboard\n",
        "    token=\"YOUR_API_KEY\",\n",
        ")\n",
        "\n",
        "# verify that you have access to the function\n",
        "catalog.list()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "95a715d2",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Access Function\n",
        "optimizer = catalog.load(\"kipu-quantum/iskay-quantum-optimizer\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4a8e24f7",
      "metadata": {},
      "source": [
        "<span id=\"custom-configuration-example\" />\n",
        "\n",
        "## 사용자 지정 구성 예시\n",
        "\n",
        "다음은 Iskay를 다양한 설정으로 구성하는 방법입니다:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "712dbae3",
      "metadata": {},
      "outputs": [],
      "source": [
        "custom_options = {\n",
        "    \"shots\": 15_000,  # Higher shot count for better statistics\n",
        "    \"num_iterations\": 12,  # More iterations for solution refinement\n",
        "    \"preprocessing_level\": 1,  # Light preprocessing for problem simplification\n",
        "    \"postprocessing_level\": 2,  # Maximum postprocessing for solution quality\n",
        "    \"transpilation_level\": 3,  # Use higher transpilation level to optimize circuit\n",
        "    \"seed_transpiler\": 42,  # Fixed seed for reproducible results\n",
        "    \"job_tags\": [\"custom_config\"],  # Custom tracking tags\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "50690350",
      "metadata": {},
      "source": [
        "**시드 최적화** : 기본값으로 `None` 로 `seed_transpiler` 설정됨에 유의하십시오. 이를 통해 트랜스파일러의 자동 최적화 프로세스가 가능해집니다. 시스템은 여러 시드(seed) `None`로 시험을 시작하고, 각 트랜스파일레이션 레벨에 대해 `max_trials` 매개변수의 전체 성능을 활용하여 최상의 회로 깊이를 생성하는 시드를 선택합니다.\n",
        "\n",
        "**트랜스파일레이션 수준 성능** : 값을 높여 개수를 `max_trials` 늘리면 `transpilation_level` 트랜스파일레이션 시간이 불가피하게 증가하지만, 최종 회로가 항상 변경되지는 않을 수 있습니다. 이는 특정 회로 구조와 복잡성에 크게 좌우됩니다. 그러나 일부 회로/문제의 경우, 10회 시도(레벨 1)와 50회 시도(레벨 5) 간의 차이가 극적일 수 있으므로, 이러한 매개변수를 탐구하는 것이 해결책을 성공적으로 찾는 열쇠가 될 수 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d4ca2590",
      "metadata": {},
      "source": [
        "<span id=\"example-1-simple-cost-function\" />\n",
        "\n",
        "## 예시 1: 단순 비용 함수\n",
        "\n",
        "스핀 공식의 비용 함수를 고려하세요:\n",
        "\n",
        "$$\n",
        "C(x_0, x_1, x_2, x_3, x_4) = 1 + 1.5x_0 + 2x_1 + 1.3x_2 + 2.5x_0x_3 + 3.5x_1x_4 + 4x_0x_1x_2\n",
        "$$\n",
        "\n",
        "여기서 $(x_0, ..., x_4) \\in \\{-1, 1\\}^5$.\n",
        "\n",
        "이 간단한 비용 함수에 대한 해결책은 다음과 같습니다\n",
        "\n",
        "$$\n",
        "(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)\n",
        "$$\n",
        "\n",
        "최소값으로 $C^{*} = -6$\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a98e8232",
      "metadata": {},
      "source": [
        "<span id=\"1-create-the-objective-function\" />\n",
        "\n",
        "### 1. 목적 함수 생성\n",
        "\n",
        "먼저 다음과 같이 목적 함수의 계수가 포함된 사전을 생성합니다:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3b4a58b1",
      "metadata": {},
      "outputs": [],
      "source": [
        "objective_func = {\n",
        "    \"()\": 1,\n",
        "    \"(0,)\": 1.5,\n",
        "    \"(1,)\": 2,\n",
        "    \"(2,)\": 1.3,\n",
        "    \"(0, 3)\": 2.5,\n",
        "    \"(1, 4)\": 3.5,\n",
        "    \"(0, 1, 2)\": 4,\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ab63b08f",
      "metadata": {},
      "source": [
        "<span id=\"2-run-the-optimizer\" />\n",
        "\n",
        "### 2. 최적화기를 실행하십시오\n",
        "\n",
        "최적화 프로그램을 실행하여 문제를 해결합니다. $(x_0, ..., x_4) \\in \\{-1, 1\\}^5$ 이후 `problem_type=spin` 을 설정해야 합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "469ae361",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Setup options to run the optimizer\n",
        "options = {\"shots\": 5000, \"num_iterations\": 5, \"use_session\": True}\n",
        "\n",
        "arguments = {\n",
        "    \"problem\": objective_func,\n",
        "    \"problem_type\": \"spin\",\n",
        "    \"backend_name\": backend_name,  # such as \"ibm_fez\"\n",
        "    \"options\": options,\n",
        "}\n",
        "\n",
        "job = optimizer.run(**arguments)\n",
        "\n",
        "# Print the ID so you can use it later, if necessary\n",
        "print(job.job_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1e3a8542",
      "metadata": {},
      "source": [
        "<span id=\"3-retrieve-the-result\" />\n",
        "\n",
        "### 3. 결과를 가져옵니다\n",
        "\n",
        "최적화 문제의 해결책은 최적화 도구에서 직접 제공합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2f74d7e2",
      "metadata": {},
      "outputs": [],
      "source": [
        "print(job.result())"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c4d0a0f8",
      "metadata": {},
      "source": [
        "그러면 양식의 사전이 표시됩니다:\n",
        "\n",
        "```\n",
        "{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},\n",
        " 'solution_info': {'bitstring': '11100',\n",
        "  'cost': -13.8,\n",
        "  'seed_transpiler': 42,\n",
        "  'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},\n",
        " 'prob_type': 'spin'}\n",
        "```\n",
        "\n",
        "사전 `solution` 에 결과 벡터 $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$ 가 표시되는 것을 확인할 수 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7eaa5cac",
      "metadata": {},
      "source": [
        "<span id=\"example-2-maxcut\" />\n",
        "\n",
        "## 예시 2: MaxCut\n",
        "\n",
        "MaxCut 또는 최대 독립 집합과 같은 많은 그래프 문제는 NP-하드 문제이며 양자 알고리즘과 하드웨어를 테스트하는 데 이상적인 후보입니다. 이 예는 퀀텀 옵티마이저를 사용하여 3-정규 그래프의 MaxCut 문제를 해결하는 방법을 보여줍니다.\n",
        "\n",
        "이 예제를 실행하려면 `qiskit-ibm-catalog` 패키지와 함께 `networkx` 패키지를 설치해야 합니다. 이를 설치하려면 다음 명령을 실행하십시오.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9ea6d138",
      "metadata": {},
      "outputs": [],
      "source": [
        "# %pip install networkx numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0c63487f",
      "metadata": {},
      "source": [
        "<span id=\"1-create-the-objective-function\" />\n",
        "\n",
        "### 1. 목적 함수 생성\n",
        "\n",
        "먼저 임의의 3-정사각형 그래프를 생성합니다. 이 그래프에서는 MaxCut 문제의 목적 함수를 정의합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d1d4017f",
      "metadata": {},
      "outputs": [],
      "source": [
        "import networkx as nx\n",
        "\n",
        "# Create a random 3-regular graph\n",
        "G = nx.random_regular_graph(3, 10, seed=42)\n",
        "\n",
        "\n",
        "# Create the objective function for MaxCut in Ising formulation\n",
        "def graph_to_ising_maxcut(G):\n",
        "    \"\"\"\n",
        "    Convert a NetworkX graph to an Ising Hamiltonian for the max-cut problem.\n",
        "    Args:\n",
        "        G (networkx.Graph): The input graph.\n",
        "    Returns:\n",
        "        dict: The objective function of the Ising model\n",
        "    \"\"\"\n",
        "    # Initialize the linear and quadratic coefficients\n",
        "    objective_func = {}\n",
        "    # Populate the coefficients\n",
        "    for i, j in G.edges:\n",
        "        objective_func[f\"({i}, {j})\"] = 0.5\n",
        "    return objective_func\n",
        "\n",
        "\n",
        "objective_func = graph_to_ising_maxcut(G)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3be09664",
      "metadata": {},
      "source": [
        "<span id=\"2-run-the-optimizer\" />\n",
        "\n",
        "### 2. 최적화기를 실행하십시오\n",
        "\n",
        "최적화 프로그램을 실행하여 문제를 해결하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2499ab67",
      "metadata": {},
      "outputs": [],
      "source": [
        "options = {\"shots\": 5000, \"num_iterations\": 5, \"use_session\": True}\n",
        "\n",
        "arguments = {\n",
        "    \"problem\": objective_func,\n",
        "    \"problem_type\": \"spin\",\n",
        "    \"backend_name\": backend_name,  # such as \"ibm_fez\"\n",
        "    \"options\": options,\n",
        "}\n",
        "\n",
        "job = optimizer.run(**arguments)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3548f6dc",
      "metadata": {},
      "source": [
        "<span id=\"3-retrieve-the-result\" />\n",
        "\n",
        "### 3. 결과를 가져옵니다\n",
        "\n",
        "결과를 검색하고 솔루션 비트스트링을 원래 그래프 노드에 다시 매핑합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "169cbd6e",
      "metadata": {},
      "outputs": [],
      "source": [
        "print(job.result())"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7f22d66a",
      "metadata": {},
      "source": [
        "Maxcut 문제에 대한 해결책은 결과 객체의 `solution` 하위 사전에 직접 포함되어 있습니다\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "38309554",
      "metadata": {},
      "outputs": [],
      "source": [
        "maxcut_solution = job.result()[\"solution\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "19a664c4",
      "metadata": {},
      "source": [
        "<span id=\"example-3-benchmark-instances\" />\n",
        "\n",
        "## 예시 3: 벤치마크 인스턴스\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "98545ce3",
      "metadata": {},
      "source": [
        "벤치마크 인스턴스는 GitHub: [Kipu 벤치마크](https://github.com/Kipu-Quantum-GmbH/benchmark-instances) 인스턴스에서 이용 가능합니다.\n",
        "\n",
        "인스턴스는 `pygithub` 라이브러리를 사용하여 로드할 수 있습니다. 이를 설치하려면 다음 명령을 실행하십시오.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1d8777e4",
      "metadata": {},
      "outputs": [],
      "source": [
        "# %pip install pygithub"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e3a03447",
      "metadata": {},
      "source": [
        "벤치마크 인스턴스의 경로는 다음과 같습니다:\n",
        "\n",
        "**Maxcut:**\n",
        "\n",
        "* `'maxcut/maxcut_regular_3_100_nodes_weighted.json'`\n",
        "* `'maxcut/maxcut_regular_3_140_nodes_weighted.json'`\n",
        "* `'maxcut/maxcut_regular_3_150_nodes_weighted.json'`\n",
        "* `'maxcut/maxcut_regular_4_130_nodes_weighted.json'`\n",
        "\n",
        "**HUBO:**\n",
        "\n",
        "* `'HUBO/hubo1_marrakesh.json'`\n",
        "* `'HUBO/hubo2_marrakesh.json'`\n",
        "\n",
        "HUBO 인스턴스에 대한 벤치마크 성능을 재현하려면 백엔드 `ibm_marrakesh` 를 선택하고 `options` 하위 사전에서 `direct_qubit_mapping` 을 `True` 로 설정합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "adbed9be",
      "metadata": {},
      "source": [
        "다음 예제는 150개의 노드를 사용하여 Maxcut 인스턴스를 실행합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "da681a18",
      "metadata": {},
      "outputs": [],
      "source": [
        "from github import Github\n",
        "import urllib\n",
        "import json\n",
        "import ast\n",
        "\n",
        "repo = \"Kipu-Quantum-GmbH/benchmark-instances\"\n",
        "path = \"maxcut/maxcut_regular_3_150_nodes_weighted.json\"\n",
        "gh = Github()\n",
        "repo = gh.get_repo(repo)\n",
        "branch = \"main\"\n",
        "file = repo.get_contents(urllib.parse.quote(path), ref=branch)\n",
        "\n",
        "# load json file with benchmark problem\n",
        "problem_json = json.loads(file.decoded_content)\n",
        "\n",
        "# convert objective function to compatible format\n",
        "objective_func = {\n",
        "    key: ast.literal_eval(value) for key, value in problem_json.items()\n",
        "}\n",
        "\n",
        "\n",
        "# Setup configuration to run the optimizer\n",
        "options = {\n",
        "    \"shots\": 5_000,\n",
        "    \"num_iterations\": 5,\n",
        "    \"use_session\": True,\n",
        "    \"direct_qubit_mapping\": False,\n",
        "}\n",
        "\n",
        "arguments = {\n",
        "    \"problem\": objective_func,\n",
        "    \"problem_type\": \"spin\",\n",
        "    \"backend_name\": \"<BACKEND-NAME>\",\n",
        "    \"options\": options,\n",
        "}\n",
        "\n",
        "job = optimizer.run(**arguments)\n",
        "\n",
        "result = job.result()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "664476ff",
      "metadata": {},
      "source": [
        "<span id=\"use-cases\" />\n",
        "\n",
        "## 유스 케이스\n",
        "\n",
        "최적화 솔버의 일반적인 사용 사례는 조합 최적화 문제입니다. 금융, 제약, 물류 등 다양한 산업 분야의 문제를 해결할 수 있습니다. 예를　\n",
        "들면，다음과　같습니다：\n",
        "\n",
        "* 포트폴리오 최적화(QUBO): [과학 출판물](https://doi.org/10.1103/PhysRevApplied.22.054037) 및 [백서](https://kipu-quantum.com/zope64/kipu_2024/content/e3915/e3916/e4187/White-Paper-2-Financial-modeling-on-quantum-computers-using-digitally-compressed-algorithms-1.pdf)\n",
        "* 단백질 접기(HUBO): [과학 출판물](https://doi.org/10.1103/PhysRevApplied.20.014024)\n",
        "* 물류 스케줄링(QUBO): [과학 출판물](https://doi.org/10.1103/PhysRevApplied.22.064068)\n",
        "* 네트워크 최적화: [웨비나](https://www.youtube.com/watch?v=w5SrCIK88No)\n",
        "* 시장 분할 (QUBO): [튜토리얼](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer)\n",
        "\n",
        "특정 사용 사례를 해결하고 전용 매핑을 개발하는 데 관심이 있으시다면 저희가 도와드릴 수 있습니다. [문의해 주세요](https://share-eu1.hsforms.com/2Ff8cgWvTR9ukT_fPoaNhDw2dqpz5).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e9ec2e67",
      "metadata": {},
      "source": [
        "<span id=\"get-support\" />\n",
        "\n",
        "## 지원 받기\n",
        "\n",
        "지원 문의는 [support@kipu-quantum.com](mailto:support@kipu-quantum.com).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5a6a25c8",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## 다음 단계\n",
        "\n",
        "* [Kipu Quantum의 Quantum Optimizer 사용 권한을 요청해 주세요](https://share-eu1.hsforms.com/2Ff8cgWvTR9ukT_fPoaNhDw2dqpz5).\n",
        "* 이 Qiskit 함수에 대한 [API 참조](/docs/api/functions/kipu-optimization) 를 확인해 보세요.\n",
        "* [키푸 퀀텀의 이스카이 퀀텀 최적화기](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer) 튜토리얼로 시장 분할 문제를 해결해 보세요.\n",
        "* 로메로, S. [V., 서평 등 (2025).  고차 이진 최적화를 위한 편향장 디지털화 반이방성 양자 알고리즘. arXiv 사전 인쇄본 arXiv:2409.04477](https://arxiv.org/abs/2409.04477).\n",
        "* 검토: [Cadavid, A. G., 등 (2024).  편향장 디지털화 대항열량적 양자 최적화 arXiv 사전 인쇄본 arXiv:2405.13898](https://arxiv.org/abs/2405.13898).\n",
        "* 리뷰 [찬다라나, P., 등 (2025).  디지털 양자 최적화를 통한 실행 시간 양자 우위 arXiv 사전 인쇄본 arXiv:2505.08663](https://arxiv.org/abs/2505.08663).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f73ef6c4",
      "metadata": {},
      "source": [
        "<span id=\"additional-information\" />\n",
        "\n",
        "## 추가 정보\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "52b5221c",
      "metadata": {},
      "source": [
        "이스케이는 회사 이름인 키푸 퀀텀과 마찬가지로 페루어입니다. 독일에서 시작한 스타트업이지만, 이 단어는 기원전 2000년 인류가 최초로 개발한 계산기 중 하나인 퀴푸가 있는 공동 창립자 중 한 명의 모국에서 유래한 말입니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "id": "a1b8767d",
      "source": "© IBM Corp., 2017-2026"
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}