{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "aea62c4c-1e42-4472-9f1d-e52783e81fc6",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"회로 라이브러리\"\n",
        "description: \"Qiskit 회로 라이브러리가 제공하는 즉시 사용 가능한 회로에 대해 자세히 알아보세요. 여기에는 N-로컬 회로, 시간 진화 회로 및 데이터 인코딩 회로가 포함됩니다\"\n",
        "---\n",
        "\n",
        "{/* cspell:ignore cout */}\n",
        "\n",
        "<span id=\"circuit-library\" />\n",
        "\n",
        "# 회로 라이브러리\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "14baab34-71a4-4d3c-bdc1-083bb2c32065",
      "metadata": {
        "tags": [
          "version-info"
        ]
      },
      "source": [
        "{/*\n",
        "  DO NOT EDIT THIS CELL!!!\n",
        "  This cell's content is generated automatically by a script. Anything you add\n",
        "  here will be removed next time the notebook is run. To add new content, create\n",
        "  a new cell before or after this one.\n",
        "  */}\n",
        "\n",
        "<Accordion>\n",
        "  <AccordionItem title=\"패키지 버전\">\n",
        "    이 페이지의 코드는 다음 요구 사항을 사용하여 개발되었습니다.\n",
        "    다음 버전 이상을 사용하는 것이 좋습니다.\n",
        "\n",
        "    ```\n",
        "    qiskit[all]~=2.5.2\n",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "id": "6f257ff9-15c4-48d8-9503-7f0ab16a91b2",
      "metadata": {},
      "source": [
        "키스킷 SDK에는 자체 프로그램에서 빌딩 블록으로 사용할 수 있는 인기 있는 회로 라이브러리가 포함되어 있습니다. 사전 정의된 회로를 사용하면 조사, 코드 작성, 디버깅에 소요되는 시간을 절약할 수 있습니다. 이 라이브러리에는 양자 컴퓨팅에서 널리 사용되는 회로, 고전적으로 시뮬레이션하기 어려운 회로, 양자 하드웨어 벤치마킹에 유용한 회로가 포함되어 있습니다.\n",
        "\n",
        "이 페이지에는 라이브러리에서 제공하는 다양한 회로 카테고리가 나열되어 있습니다. 전체 회로 목록은 [회로 라이브러리 API 문서를](/docs/api/qiskit/circuit_library) 참조하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0b473350",
      "metadata": {},
      "source": [
        "<span id=\"standard-gates\" />\n",
        "\n",
        "## 표준 게이트\n",
        "\n",
        "회로 라이브러리에는 표준 양자 게이트도 포함되어 있습니다. 일부는 보다 기본적인 게이트(예: `UGate`)이며, 다른 일부는 일반적으로 단일 및 2큐비트 게이트로부터 구축해야 하는 멀티큐비트 게이트입니다. 가져온 게이트를 회로에 추가하려면 `append` 메서드를 사용하세요. 첫 번째 인수는 게이트이고, 다음 인수는 게이트를 적용할 큐비트 목록입니다.\n",
        "\n",
        "예를 들어, 다음 코드 셀은 하다마드 게이트와 다중 제어 X 게이트로 회로를 생성합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "a846a845-7ac5-4c92-b124-d2b90a773ba2",
      "metadata": {
        "tags": [
          "ignore-warnings"
        ]
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/a846a845-7ac5-4c92-b124-d2b90a773ba2-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit import QuantumCircuit\n",
        "from qiskit.circuit.library import HGate, MCXGate\n",
        "\n",
        "mcx_gate = MCXGate(3)\n",
        "hadamard_gate = HGate()\n",
        "\n",
        "qc = QuantumCircuit(4)\n",
        "qc.append(hadamard_gate, [0])\n",
        "qc.append(mcx_gate, [0, 1, 2, 3])\n",
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e5066595",
      "metadata": {},
      "source": [
        "회로 라이브러리 API 문서에서 [표준 게이트를](/docs/api/qiskit/circuit_library#standard-gates) 참조하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f1d7c8c9-1b4d-45e1-9cd5-c5d76c2e25ab",
      "metadata": {},
      "source": [
        "<span id=\"n-local-circuits\" />\n",
        "\n",
        "## N-로컬 회로\n",
        "\n",
        "이 회로는 단일 큐비트 회전 게이트 레이어와 다중 큐비트 얽힘 게이트 레이어를 번갈아 사용합니다.\n",
        "\n",
        "이 회로 제품군은 다양한 양자 상태를 생성할 수 있기 때문에 가변 양자 알고리즘에서 널리 사용됩니다. 가변 알고리즘은 게이트 파라미터를 조정하여 특정 속성(예: 최적화 문제에 대한 좋은 솔루션을 나타내는 상태)을 가진 상태를 찾습니다. 이를 위해 라이브러리의 많은 회로가 **파라미터화되어** 있어 고정된 값 없이도 정의할 수 있습니다.\n",
        "\n",
        "다음 코드 셀은 인탱글링 게이트가 2큐비트 게이트인 `n_local` 회로를 가져옵니다. 이 회로는 파라미터화된 단일 큐비트 게이트 블록을 인터리브한 다음, 2큐비트 게이트 블록을 얽어매는 방식입니다. 다음 코드는 단일 큐비트 RX 게이트와 2큐비트 CZ 게이트로 구성된 3큐비트 회로를 생성합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "3ccaeb1b-03c6-4dfa-9000-e48db2516303",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/3ccaeb1b-03c6-4dfa-9000-e48db2516303-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import n_local\n",
        "\n",
        "two_local = n_local(3, \"rx\", \"cz\")\n",
        "two_local.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e32e031b-3218-4c1c-af7c-b40ad6c82100",
      "metadata": {},
      "source": [
        "`parameters` 속성에서 회로 매개변수의 목록형 객체를 가져올 수 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "d503e1c8-0ccd-4868-a5dc-4806d00ab54b",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "two_local.parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "555aca2a-a754-4372-8846-22ee4773ece1",
      "metadata": {},
      "source": [
        "`{ Parameter: number }` 형식의 사전을 사용하여 이러한 매개변수를 실제 값에 할당하는 데 사용할 수도 있습니다. 이를 보여주기 위해 다음 코드 셀은 회로의 각 파라미터를 `0` 에 할당합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "89227b48-12b2-4b1b-9680-55a7fce88a2b",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/89227b48-12b2-4b1b-9680-55a7fce88a2b-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "bound_circuit = two_local.assign_parameters(\n",
        "    {p: 0 for p in two_local.parameters}\n",
        ")\n",
        "bound_circuit.decompose().draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "78772993-d0da-4651-9211-706e86a59432",
      "metadata": {},
      "source": [
        "자세한 내용은 회로 라이브러리 API 설명서에서 [N-로컬 게이트를](/docs/api/qiskit/circuit_library#n-local-circuits) 참조하거나 IBM 양자 학습에서 [변형 알고리즘 설계 과정을](/learning/courses/variational-algorithm-design) 수강하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3e463081-bce9-4ee2-9046-97659e9ac847",
      "metadata": {},
      "source": [
        "<span id=\"data-encoding-circuits\" />\n",
        "\n",
        "## 데이터 인코딩 회로\n",
        "\n",
        "이러한 파라미터화된 회로는 양자 머신러닝 알고리즘이 처리할 수 있도록 데이터를 양자 상태로 인코딩합니다. 키스킷에서 지원하는 일부 회로는 다음과 같습니다:\n",
        "\n",
        "* 진폭 인코딩은 각 숫자를 기저 상태의 진폭으로 인코딩합니다. 이렇게 하면 $2^n$ 번호를 단일 상태로 저장할 수 있지만 구현하는 데 비용이 많이 들 수 있습니다.\n",
        "* 기저 인코딩은 해당 기저 상태 $|k\\rangle$ 를 준비하여 정수 $k$ 를 인코딩합니다.\n",
        "* 각도 인코딩은 데이터의 각 숫자를 매개변수화된 회로의 회전 각도로 설정합니다.\n",
        "\n",
        "가장 좋은 접근 방식은 애플리케이션의 특성에 따라 다릅니다. 그러나 현재 양자 컴퓨터에서는 종종 `zz_feature_map` 와 같은 각도 인코딩 회로를 사용합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "cf8b1efc-57b3-4681-8e6a-d5b8406d092d",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/cf8b1efc-57b3-4681-8e6a-d5b8406d092d-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import zz_feature_map\n",
        "\n",
        "features = [0.2, 0.4, 0.8]\n",
        "feature_map = zz_feature_map(feature_dimension=len(features))\n",
        "\n",
        "encoded = feature_map.assign_parameters(features)\n",
        "encoded.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "031bf004-ca80-4cc0-b153-2cd5cd778386",
      "metadata": {},
      "source": [
        "회로 라이브러리 API 문서에서 [데이터 인코딩 회로를](/docs/api/qiskit/circuit_library#data-encoding-circuits) 참조하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5c5d2735-ef6a-48db-8382-9dc03c9af20a",
      "metadata": {},
      "source": [
        "<span id=\"time-evolution-circuits\" />\n",
        "\n",
        "## 시간 진화 회로\n",
        "\n",
        "이 회로는 시간에 따라 진화하는 양자 상태를 시뮬레이션합니다. 시간 진화 회로를 사용하여 시스템의 열 전달 또는 상 전이와 같은 물리적 효과를 조사합니다. 시간 진화 회로는 화학 파동 함수(예: 단일 결합 클러스터 시험 상태)와 최적화 문제에 사용하는 QAOA 알고리즘의 기본 구성 요소이기도 합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "834794df-86e9-4bea-8efa-5380499e359b",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/834794df-86e9-4bea-8efa-5380499e359b-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import PauliEvolutionGate\n",
        "from qiskit.circuit import QuantumCircuit\n",
        "from qiskit.quantum_info import SparsePauliOp\n",
        "\n",
        "\n",
        "# Prepare an initial state with a Hadamard on the middle qubit\n",
        "state = QuantumCircuit(3)\n",
        "state.h(1)\n",
        "\n",
        "hamiltonian = SparsePauliOp([\"ZZI\", \"IZZ\"])\n",
        "evolution = PauliEvolutionGate(hamiltonian, time=1)\n",
        "\n",
        "# Evolve state by appending the evolution gate\n",
        "state.compose(evolution, inplace=True)\n",
        "\n",
        "state.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e2dad12f-535a-4f42-8ac4-dbfcfb5533cc",
      "metadata": {},
      "source": [
        "[`PauliEvolutionGate` API 설명서를](/docs/api/qiskit/qiskit.circuit.library.PauliEvolutionGate) 읽어보세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0cf7122d-c3fe-41a6-936c-b3770b33f0f1",
      "metadata": {},
      "source": [
        "<span id=\"benchmarking-and-complexity-theory-circuits\" />\n",
        "\n",
        "## 벤치마킹 및 복잡도 이론 회로\n",
        "\n",
        "벤치마킹 회로를 통해 하드웨어가 실제로 얼마나 잘 작동하는지 파악할 수 있고, 복잡성 이론 회로를 통해 해결하려는 문제가 얼마나 어려운지 이해할 수 있습니다.\n",
        "\n",
        "예를 들어, '양자 볼륨' 벤치마크는 양자 컴퓨터가 일종의 무작위 양자 회로를 얼마나 정확하게 실행하는지를 측정합니다. 양자 컴퓨터의 점수는 안정적으로 실행할 수 있는 회로의 크기에 따라 증가합니다. 여기에는 큐비트 수, 명령 충실도, 큐비트 연결성, 소프트웨어 스택 트랜스파일링 및 후처리 결과 등 컴퓨터의 모든 측면이 고려됩니다. 퀀텀 볼륨에 대한 자세한 내용은 [퀀텀 볼륨 백서](https://arxiv.org/abs/1811.12926) 원본을 참조하세요.\n",
        "\n",
        "다음 코드는 4개의 큐비트( `unitary` 블록은 무작위 2큐비트 게이트)로 실행되는 키스킷에 구축된 양자 볼륨 회로의 예를 보여줍니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "9629a507-8191-409e-b895-fd0833c8fcd7",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/9629a507-8191-409e-b895-fd0833c8fcd7-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import quantum_volume\n",
        "\n",
        "quantum_volume(4).draw(\"mpl\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "id": "908e4b4a-5edf-4390-82a0-e755050c2a37",
      "metadata": {},
      "source": [
        "회로 라이브러리에는 순간 양자 다항식(iqp) 회로와 같이 고전적으로 시뮬레이션하기 어렵다고 여겨지는 회로도 포함되어 있습니다. 이 회로는 특정 대각선 게이트(계산 기준)를 하다마드 게이트 블록 사이에 끼워 넣습니다.\n",
        "\n",
        "다른 회로로는 그로버 알고리즘에 사용되는 `grover_operator` 회로와 푸리에 검사 문제를 위한 `fourier_checking` 회로가 있습니다. 회로 라이브러리 API 문서의 [특정 양자 회로에서](/docs/api/qiskit/circuit_library#particular-quantum-circuits) 이러한 회로를 확인하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "58b1a7b8-c173-4de8-957a-ca5d58332073",
      "metadata": {},
      "source": [
        "<span id=\"arithmetic-circuits\" />\n",
        "\n",
        "## 산술 회로\n",
        "\n",
        "산술 연산은 정수 더하기와 비트 단위 연산과 같은 고전적인 함수입니다. 이는 금융 애플리케이션의 진폭 추정과 같은 알고리즘이나 선형 방정식 시스템을 푸는 HHL 알고리즘과 같은 알고리즘에 유용하게 사용될 수 있습니다.\n",
        "\n",
        "예를 들어 제자리 덧셈을 수행하는 '리플 캐리' 회로를 사용하여 3비트 숫자 두 개를 더해보겠습니다(`FullAdderGate`). 이 덧셈기는 두 개의 숫자(\"A\"와 \"B\"라고 하겠습니다)를 더하고 그 결과를 B가 저장된 레지스터에 씁니다. 다음 예에서는 A=2 및 B=3.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "77555a5a-a81c-47b8-a9ae-3015d84adcf5",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/circuit-library/extracted-outputs/77555a5a-a81c-47b8-a9ae-3015d84adcf5-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import FullAdderGate\n",
        "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
        "\n",
        "adder = FullAdderGate(3)  # Adder of 3-bit numbers\n",
        "\n",
        "# Create the number A=2\n",
        "reg_a = QuantumRegister(3, \"a\")\n",
        "number_a = QuantumCircuit(reg_a)\n",
        "number_a.initialize(2)  # Number 2; |010>\n",
        "\n",
        "# Create the number B=3\n",
        "reg_b = QuantumRegister(3, \"b\")\n",
        "number_b = QuantumCircuit(reg_b)\n",
        "number_b.initialize(3)  # Number 3; |011>\n",
        "\n",
        "# Create a circuit to hold everything, including a classical register for\n",
        "# the result\n",
        "qregs = [\n",
        "    QuantumRegister(1, \"cin\"),\n",
        "    QuantumRegister(3, \"a\"),\n",
        "    QuantumRegister(3, \"b\"),\n",
        "    QuantumRegister(1, \"cout\"),\n",
        "]\n",
        "reg_result = ClassicalRegister(3)\n",
        "circuit = QuantumCircuit(*qregs, reg_result)\n",
        "\n",
        "# Compose number initializers with the adder. Adder stores the result to\n",
        "# register B, so we'll measure those qubits.\n",
        "circuit = (\n",
        "    circuit.compose(number_a, qubits=reg_a)\n",
        "    .compose(number_b, qubits=reg_b)\n",
        "    .compose(adder)\n",
        ")\n",
        "circuit.measure(reg_b, reg_result)\n",
        "circuit.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e8a8deee-ad46-42cd-844e-51d5541c3f65",
      "metadata": {},
      "source": [
        "회로를 시뮬레이션하면 모든 `1024` 샷에 대해 `5` 을 출력합니다(즉, 확률로 측정됨 `1.0`).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "ede21ca4-0358-4c83-9af5-63a1c67ae3cb",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Count data:\n",
            " {5: 1024}\n"
          ]
        }
      ],
      "source": [
        "from qiskit.primitives import StatevectorSampler\n",
        "\n",
        "result = StatevectorSampler().run([circuit]).result()\n",
        "\n",
        "print(f\"Count data:\\n {result[0].data.c0.get_int_counts()}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cbd99d49-eb5c-4cd5-bac2-528497b8405e",
      "metadata": {},
      "source": [
        "회로 라이브러리 API 문서에서 [산술을](/docs/api/qiskit/circuit_library#arithmetic) 참조하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9a900a84-c52f-4a03-b3e9-87c71fa93e88",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## 다음 단계\n",
        "\n",
        "<Admonition type=\"tip\" title=\"권장사항\">\n",
        "  * [‘Construct 회로](/docs/guides/construct-circuits) ’ 주제에서 회로를 만드는 고급 기법을 배워보세요.\n",
        "  * [그로버 알고리즘](/docs/tutorials/grovers-algorithm) 튜토리얼에서 회로의 사용 예시를 확인하세요.\n",
        "  * [회로 라이브러리 API](/docs/api/qiskit/circuit_library) 참조를 검토하세요.\n",
        "</Admonition>\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
}