{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "bc54d7bc-b2d8-4b30-9b0b-05689e07a463",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"회로 구성\"\n",
        "description: \"Qiskit에서 양자 회로를 구성하고 시각화하는 방법.\"\n",
        "---\n",
        "\n",
        "<span id=\"construct-circuits\" />\n",
        "\n",
        "# 회로 구성\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e11dd8ad-7edc-4cf8-bc13-388fe04e84fa",
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d",
      "metadata": {},
      "source": [
        "이 페이지에서는 키스킷 SDK의 [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) 클래스를 자세히 살펴보고, 양자 회로를 만드는 데 사용할 수 있는 몇 가지 고급 메서드를 포함합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2664d407-aa95-43a3-9101-d3ad58c2df58",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-quantum-circuit\" />\n",
        "\n",
        "## 양자 회로란 무엇인가?\n",
        "\n",
        "간단한 양자 회로는 큐비트와 그 큐비트에 작용하는 명령어 목록의 모음입니다. 이를 보여주기 위해 다음 셀은 두 개의 새로운 큐비트로 새 회로를 생성한 다음, 해당 회로의 [`qubits`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qubits) 속성을 표시합니다 [`Qubits`](/docs/api/qiskit/circuit#qiskit.circuit.Qubit) 최하위 비트 $q_0$ 부터 최상위 비트 $q_n$ 까지 순서대로 표시합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "b410d397-b67d-4f31-90cf-9c1c34c157c5",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<Qubit register=(2, \"q\"), index=0>, <Qubit register=(2, \"q\"), index=1>]"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit import QuantumCircuit\n",
        "\n",
        "qc = QuantumCircuit(2)\n",
        "qc.qubits"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "392e3d6c",
      "metadata": {},
      "source": [
        "여러 개의 `QuantumRegister` 및 `ClassicalRegister` 개체를 결합하여 회로를 만들 수 있습니다. 모든 [`QuantumRegister`](/docs/api/qiskit/circuit#qiskit.circuit.QuantumRegister) 및 [`ClassicalRegister`](/docs/api/qiskit/circuit#qiskit.circuit.ClassicalRegister) 도 이름을 지정할 수 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "6160e3f7",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<Qubit register=(2, \"qreg1\"), index=0>,\n",
              " <Qubit register=(2, \"qreg1\"), index=1>,\n",
              " <Qubit register=(1, \"qreg2\"), index=0>]"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit import QuantumRegister, ClassicalRegister\n",
        "\n",
        "qr1 = QuantumRegister(2, \"qreg1\")  # Create a QuantumRegister with 2 qubits\n",
        "qr2 = QuantumRegister(1, \"qreg2\")  # Create a QuantumRegister with 1 qubit\n",
        "cr1 = ClassicalRegister(3, \"creg1\")  # Create a ClassicalRegister with 3 cbits\n",
        "\n",
        "combined_circ = QuantumCircuit(\n",
        "    qr1, qr2, cr1\n",
        ")  # Create a quantum circuit with 2 QuantumRegisters and 1 ClassicalRegister\n",
        "combined_circ.qubits"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e7b212f",
      "metadata": {},
      "source": [
        "큐비트의 인덱스를 찾고 등록하려면 회로의 [`find_bit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.find_bit) 메서드와 그 어트리뷰트를 사용하면 됩니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "faeb3fbc",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Index: 2\n",
            "Register: [(QuantumRegister(1, 'qreg2'), 0)]\n"
          ]
        }
      ],
      "source": [
        "desired_qubit = qr2[0]  # Qubit 0 of register 'qreg2'\n",
        "\n",
        "print(\"Index:\", combined_circ.find_bit(desired_qubit).index)\n",
        "print(\"Register:\", combined_circ.find_bit(desired_qubit).registers)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f5c95cb2-a94f-48f3-b2a6-8ec6c25da5cd",
      "metadata": {},
      "source": [
        "회로에 인스트럭션을 추가하면 해당 인스트럭션이 회로의 [`data`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#data) 어트리뷰트에 인스트럭션을 추가합니다. 다음 셀 출력은 `data` 의 목록입니다 [`CircuitInstruction`](/docs/api/qiskit/qiskit.circuit.CircuitInstruction) 객체의 목록이며, 각 객체에는 `operation` 어트리뷰트와 `qubits` 어트리뷰트가 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "f7b5573c-b2b2-4cbf-ba55-c53c9221ce71",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[CircuitInstruction(operation=Instruction(name='x', num_qubits=1, num_clbits=0, params=[]), qubits=(<Qubit register=(2, \"q\"), index=0>,), clbits=())]"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc.x(0)  # Add X-gate to qubit 0\n",
        "qc.data"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "17a82d8a-b717-44b8-b3f8-ce89e2588261",
      "metadata": {},
      "source": [
        "이 정보를 확인하는 가장 쉬운 방법은 회로 시각화 결과를 반환하는 [`draw`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#draw) 메서드를 이용하는 것입니다. 양자 회로를 표시하는 다양한 방법에 대해서는 [‘회로 시각화’를](/docs/guides/visualize-circuits) 참조하십시오.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "43a57258-3e33-4071-8a48-2bf127c8a5be",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/43a57258-3e33-4071-8a48-2bf127c8a5be-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ab5f4bc9-7d7c-4ee7-b1bc-70a313b4fe29",
      "metadata": {},
      "source": [
        "회로 명령어 객체에는 보다 기본적인 명령어 측면에서 명령어를 설명하는 '정의' 회로가 포함될 수 있습니다. 예를 들어, [X-게이트는](/docs/api/qiskit/qiskit.circuit.library.XGate) 특정 경우의 [U3-gate](/docs/api/qiskit/qiskit.circuit.library.U3Gate) 보다 일반적인 단일 큐비트 게이트로 정의됩니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "653e2427-e301-4d2f-84de-1959185ace8e",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/653e2427-e301-4d2f-84de-1959185ace8e-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Draw definition circuit of 0th instruction in `qc`\n",
        "qc.data[0].operation.definition.draw(\"mpl\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "id": "ee893af1-db43-449f-bfc4-8f636bd98546",
      "metadata": {},
      "source": [
        "명령어와 회로는 모두 비트와 큐비트에 대한 연산을 설명한다는 점에서 비슷하지만 목적이 다릅니다:\n",
        "\n",
        "* 인스트럭션은 고정된 것으로 취급되며, 해당 메서드는 일반적으로 (원래 객체를 변경하지 않고) 새 인스트럭션을 반환합니다.\n",
        "* 회로는 여러 줄의 코드에 걸쳐 구축되도록 설계되며 [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) 메서드는 종종 기존 객체를 변경합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2e451022",
      "metadata": {},
      "source": [
        "<span id=\"what-is-circuit-depth\" />\n",
        "\n",
        "### 회로 깊이란 무엇인가?\n",
        "\n",
        "양자 회로의 [깊이()](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.depth) 는 병렬로 실행되는 양자 게이트의 '레이어' 수를 측정한 값으로, 회로에 정의된 연산을 완료하는 데 걸리는 시간을 의미합니다. 양자 게이트는 구현하는 데 시간이 걸리기 때문에 회로의 깊이는 양자 컴퓨터가 회로를 실행하는 데 걸리는 시간과 대략적으로 일치합니다. 따라서 회로의 깊이는 양자 회로가 장치에서 실행될 수 있는지 여부를 측정하는 데 사용되는 중요한 수량 중 하나입니다.\n",
        "\n",
        "이 페이지의 나머지 부분에서는 양자 회로를 조작하는 방법을 설명합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ff4f08f3-48eb-454c-9647-2af505bf79bc",
      "metadata": {},
      "source": [
        "<span id=\"build-circuits\" />\n",
        "\n",
        "## 회로를 구축하다\n",
        "\n",
        "다음과 같은 메서드 [`QuantumCircuit.h`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#h) 및 [`QuantumCircuit.cx`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#cx) 회로에 특정 지침을 추가합니다. 보다 일반적으로 회로에 인스트럭션을 추가하려면 [`append`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#append) 메서드를 사용합니다. 여기에는 인스트럭션과 인스트럭션을 적용할 큐비트 목록이 필요합니다. 지원되는 지침 목록은 [서킷 라이브러리 API 설명서를](/docs/api/qiskit/circuit_library) 참조하세요.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "66813cae-9841-47ea-96b7-8fd7b82e9759",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/66813cae-9841-47ea-96b7-8fd7b82e9759-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import HGate\n",
        "\n",
        "qc = QuantumCircuit(1)\n",
        "qc.append(\n",
        "    HGate(),  # New HGate instruction\n",
        "    [0],  # Apply to qubit 0\n",
        ")\n",
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bbdbef08-07c0-4fb0-ab3e-ed6efb7a3dc3",
      "metadata": {},
      "source": [
        "두 회로를 결합하려면 [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) 메서드를 사용합니다. 이것은 다른 [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) 와 선택적 큐비트 매핑 목록을 받습니다.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  메서드는 [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) 메서드는 새 회로를 반환하며 작동하는 회로를 **변경하지** 않습니다. 메서드를 호출하는 회로를 변경하려면 [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) 메서드를 호출하는 회로를 변경하려면 `inplace=True` 인수를 사용합니다.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "29152dfa-2275-4bc4-aadb-82185b9e0e86",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/29152dfa-2275-4bc4-aadb-82185b9e0e86-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc_a = QuantumCircuit(4)\n",
        "qc_a.x(0)\n",
        "\n",
        "qc_b = QuantumCircuit(2, name=\"qc_b\")\n",
        "qc_b.y(0)\n",
        "qc_b.z(1)\n",
        "\n",
        "# keep qubits (0, 1) of qc_a with same index.\n",
        "# compose qubits (0,1) of qc_b to qubits (1, 3), respectively, of new composite circuit\n",
        "combined = qc_a.compose(qc_b, qubits=[1, 3])\n",
        "combined.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d4529506-8397-4208-9cfd-31e1a1978741",
      "metadata": {},
      "source": [
        "회로를 정리하기 위해 회로를 지침으로 컴파일할 수도 있습니다. 메서드를 사용하여 회로를 인스트럭션으로 변환할 수 있습니다 [`to_instruction`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_instruction) 메서드를 사용하여 회로를 인스트럭션으로 변환한 다음 다른 인스트럭션과 마찬가지로 다른 회로에 추가할 수 있습니다. 다음 셀에 그려진 회로는 이전 셀에 그려진 회로와 기능적으로 동일합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "81b682dd-45cb-4492-809e-d9e8ebbf5600",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/81b682dd-45cb-4492-809e-d9e8ebbf5600-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "inst = qc_b.to_instruction()\n",
        "qc_a.append(inst, [1, 3])\n",
        "qc_a.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e81c46b-a2d2-430e-9d3d-73e5030e3548",
      "metadata": {},
      "source": [
        "회로가 단일 회로인 경우 다음을 사용하여 [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) 로 변환할 수 있습니다 [`to_gate`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_gate) 메서드를 사용하여 변환할 수 있습니다. [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) 객체는 특정 유형의 명령어로, 양자 제어를 추가하는 [`control`](/docs/api/qiskit/qiskit.circuit.Gate#control) 메서드처럼 양자 제어를 추가합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "ed362e64-d6a4-4dfd-a5cf-5e6bdc7a81b5",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/ed362e64-d6a4-4dfd-a5cf-5e6bdc7a81b5-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "gate = qc_b.to_gate().control()\n",
        "qc_a.append(gate, [0, 1, 3])\n",
        "qc_a.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae850362-84eb-4998-a2cf-a93a1be4ac2a",
      "metadata": {},
      "source": [
        "무슨 일이 일어나고 있는지 확인하려면 [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) 메서드를 사용하여 각 명령어를 해당 정의로 확장할 수 있습니다.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  메서드는 [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) 메서드는 새 회로를 반환하고 작동하는 회로를 **변경하지** 않습니다.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "3c0633db-929b-4428-a888-7a3d493bd6dd",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/3c0633db-929b-4428-a888-7a3d493bd6dd-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc_a.decompose().draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "87f1e053",
      "metadata": {},
      "source": [
        "<span id=\"measure-qubits\" />\n",
        "\n",
        "<span id=\"measure-qubits\" />\n",
        "\n",
        "## 큐비트 측정\n",
        "\n",
        "측정 과정은 개별 큐비트의 상태를 샘플링하고 그 결과를 고전적 레지스터로 전송하는 데 사용됩니다. [샘플러](/docs/guides/get-started-with-sampler) 프리미티브에 회로를 제출할 경우, 측정값을 반드시 포함해야 합니다. 단, [Estimator](/docs/guides/get-started-with-estimator) 프리미티브에 전달되는 회로에는 측정값이 포함되어서는 안 됩니다.\n",
        "\n",
        "큐비트는 다음 세 가지 방법으로 측정할 수 있습니다: [`measure`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.measure), [`measure_all`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_all) 및 [`measure_active`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_active). 측정 결과를 시각화하는 방법은 [‘결과 시각화’](/docs/guides/visualize-results) 페이지를 참조하십시오.\n",
        "\n",
        "1. `QuantumCircuit.measure` 는 첫 번째 인수의 각 큐비트를 두 번째 인자로 주어진 클래식 비트에 측정합니다. 이 방법을 사용하면 측정 결과가 저장되는 위치를 완벽하게 제어할 수 있습니다.\n",
        "\n",
        "2. `QuantumCircuit.measure_all` 는 인수를 받지 않으며 사전 정의된 클래식 비트 없이 양자 회로에 사용할 수 있습니다. 클래식 와이어를 생성하고 측정 결과를 순서대로 저장합니다. 예를 들어, 큐비트 $q_i$ 의 측정값은 cbit $meas_i$ )에 저장됩니다. 또한 측정 전에 배리어를 추가합니다.\n",
        "\n",
        "3. `QuantumCircuit.measure_active` `measure_all` 와 유사하지만 연산이 있는 큐비트만 측정합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "0cdb2273",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/0cdb2273-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc1 = QuantumCircuit(2, 2)\n",
        "qc1.measure(0, 1)\n",
        "qc1.draw(\"mpl\", cregbundle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "6f33698c",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/6f33698c-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc2 = QuantumCircuit(2)\n",
        "qc2.measure_all()\n",
        "qc2.draw(\"mpl\", cregbundle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "ca3f225f",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/ca3f225f-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc3 = QuantumCircuit(2)\n",
        "qc3.x(1)\n",
        "qc3.measure_active()\n",
        "qc3.draw(\"mpl\", cregbundle=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "649fc3fd-caf1-45f1-ad8e-3b5d26ca859b",
      "metadata": {},
      "source": [
        "<span id=\"parameterized-circuits\" />\n",
        "\n",
        "## 매개변수화된 회로\n",
        "\n",
        "많은 단기 양자 알고리즘은 양자 회로의 다양한 변형을 실행하는 것을 포함합니다. 대규모 회로를 구성하고 최적화하는 것은 계산 비용이 많이 들 수 있으므로, 키스킷은 **매개변수화된** 회로를 지원합니다. 이러한 회로에는 정의되지 않은 매개변수가 있으며, 회로를 실행하기 직전까지 해당 값을 정의할 필요가 없습니다. 이를 통해 회로 구성 및 최적화를 메인 프로그램 루프 밖으로 옮길 수 있습니다.  다음 셀은 매개변수화된 회로를 생성하고 표시합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "a580552c-d585-4047-99f0-32aafd06e4f3",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/a580552c-d585-4047-99f0-32aafd06e4f3-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.transpiler import generate_preset_pass_manager\n",
        "from qiskit.circuit import Parameter\n",
        "\n",
        "angle = Parameter(\"angle\")  # undefined number\n",
        "\n",
        "# Create and optimize circuit once\n",
        "qc = QuantumCircuit(1)\n",
        "qc.rx(angle, 0)\n",
        "qc = generate_preset_pass_manager(\n",
        "    optimization_level=3, basis_gates=[\"u\", \"cx\"]\n",
        ").run(qc)\n",
        "\n",
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a174600b-8f4a-47ca-aa4c-cd16dcbecb7c",
      "metadata": {},
      "source": [
        "다음 셀은 이 회로의 다양한 변형을 생성하고 그 중 하나를 표시합니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "85af6231-921a-4130-99d3-f6998f761df8",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/85af6231-921a-4130-99d3-f6998f761df8-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "circuits = []\n",
        "for value in range(100):\n",
        "    circuits.append(qc.assign_parameters({angle: value}))\n",
        "\n",
        "circuits[0].draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ede2ff7c-5e68-4458-87b3-887b5b027ee1",
      "metadata": {},
      "source": [
        "회로의 정의되지 않은 매개변수 목록은 `parameters` 속성에서 찾을 수 있습니다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "0990b840-f8c4-4416-b2b5-9861173a9471",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ParameterView([Parameter(angle)])"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc.parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8e415c37",
      "metadata": {},
      "source": [
        "<span id=\"change-a-parameters-name\" />\n",
        "\n",
        "### 매개변수 이름 변경\n",
        "\n",
        "기본적으로 매개변수화된 회로의 매개변수 이름은 -로 시작합니다 `x`. 예를 들어, `x[0]`. 정의된 후에도 이름을 변경할 수 있습니다. 다음 예시에서 확인할 수 있듯이.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "id": "1d3e6424",
      "metadata": {},
      "outputs": [],
      "source": [
        "from qiskit.circuit.library import z_feature_map\n",
        "from qiskit.circuit import ParameterVector\n",
        "\n",
        "# Define a parameterized circuit with default names\n",
        "# For example, x[0]\n",
        "circuit = z_feature_map(2)\n",
        "\n",
        "# Set new parameter names\n",
        "# They will now be prefixed by `hi` instead\n",
        "# For example, hi[0]\n",
        "training_params = ParameterVector(\"hi\", 2)\n",
        "\n",
        "# Assign parameter names to the quantum circuit\n",
        "circuit = circuit.assign_parameters(parameters=training_params)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5af44bc3",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## 다음 단계\n",
        "\n",
        "<Admonition type=\"tip\" title=\"권장사항\">\n",
        "  * 단기 양자 알고리즘에 대해 알아보려면 [변형 알고리즘 설계](/learning/courses/variational-algorithm-design) 과정을 수강하세요.\n",
        "  * [그로버 알고리즘](/docs/tutorials/grovers-algorithm) 튜토리얼에서 회로의 사용 예시를 참조하세요.\n",
        "  * [IBM 퀀텀 컴포저를](/docs/guides/composer) 사용하여 간단한 회로로 작업하세요.\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
}