{
"cells": [
{
"cell_type": "markdown",
"id": "b6d1e3ec",
"metadata": {},
"source": [
"---\n",
"title: \"ParityQC 의 Parity Twine 최적화기를 통해 시장 분할 문제를 해결하세요\"\n",
"description: \"Parity Twine Optimizer를 사용하여 시장 분할 문제를 해결하는 방법을 알아보세요.\"\n",
"---\n",
"\n",
"{/* cspell:ignore parityqc QOBLIB marketsplit independentset */}\n",
"\n",
"\n",
"\n",
"# ParityQC 의 Parity Twine 최적화기를 통해 시장 분할 문제를 해결하세요\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "a6f69b77",
"metadata": {},
"source": [
"예상 *실행 시간: Nighthawk r2 프로세서에서 10초. (참고: 이는 단지 추정치일 뿐입니다. (실행 시간은 다를 수 있습니다.)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "21156b6f",
"metadata": {},
"source": [
"\n",
"\n",
"## 학습 성과\n",
"\n",
"* [QOBLIB(양자 최적화 벤치마킹 라이브러리](https://github.com/ZIB-AOPT/QOBLIB) )에서 Market Split 문제를 가져와 형식을 지정하십시오.\n",
"* Parity Twine Optimizer를 설정하고 사용하여 마켓 스플릿 사례를 해결합니다.\n",
"* Parity Twine Optimizer의 옵션을 선택하는 방법과 어떤 결과가 출력되는지 알아보세요.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d185259f257c1618",
"metadata": {},
"source": [
"\n",
"\n",
"## 배경\n",
"\n",
"이 튜토리얼에서는 ‘ ParityQC ’의 Parity Twine 최적화기를 사용하여 마켓 스플릿(Market Split) 문제를 해결하는 방법을 설명합니다.\n",
"\n",
"이 문제 인스턴스는 [QOBLIB(양자 최적화 벤치마킹 라이브러리](https://github.com/ZIB-AOPT/QOBLIB) )에서 가져온 것입니다.\n",
"\n",
"\n",
"\n",
"### 시장 분할 문제\n",
"\n",
"시장 분할 문제는 실제 상황에서 발생하는 NP-어려운 자원 배분 문제이며, 양자 최적화 알고리즘의 벤치마크로 자리 잡았다.\n",
"이는 매우 중요한 물류적 과제를 의미합니다. 바로 고객과 제품으로 이루어진 복잡한 구도를 관리하기 쉽고 균등하게 분할된 영업 구역으로 어떻게 나눌 것인가 하는 문제입니다.\n",
"\n",
"목표는 $n$ 시장을 두 개의 균형 잡힌 판매 지역으로 나누어, 각 지역이 $m$ 제품에 대한 총 수요의 정확히 절반을 차지하도록 하는 것입니다.\n",
"이 솔루션은 제품 수요를 가능한 한 균등하게 분산시키는 구체적인 구성으로, 이를 통해 기업은 두 지역 간의 균형을 맞춘 물류 및 인력 배치 전략을 수립할 수 있으며,\n",
"이로써 특정 지역의 제품 부족이나 창고 과밀화와 같은 위험을 최소화할 수 있습니다.\n",
"\n",
"시장과 제품의 수가 증가함에 따라 가능한 조합의 수는 기하급수적으로 늘어나기 때문에, 기존의 완전 탐색 방식으로는 최적의 분할 방안을 찾기 어렵습니다.\n",
"\n",
"\n",
"\n",
"### 수학적 공식화\n",
"\n",
"$A$ 를 시장 전반에 걸친 제품 수요를 나타내는 $m \\times n$ 차 행렬이라고 하자. 여기서 $A_{ij}$ 는 시장 $j$ 에서 제품 $i$ 에 대한 수요를 나타낸다.\n",
"\n",
"이진 할당 벡터 $x = [x_1, x_2, \\dots, x_n]^T \\in \\{0, 1\\}^n$ 는 다음과 같이 정의된다:\n",
"\n",
"* $x_j = 1$ 지역 A에 시장 $j$ 을 할당합니다.\n",
"* $x_j = 0$ 지역 B에 시장 $j$ 를 할당합니다.\n",
"\n",
"$d = [d_1, d_2, \\dots, d_m]^T$ 을 각 제품의 총 수요 벡터로 정의하며, 이는 $d = A \\cdot \\mathbf{1}$ 으로 계산된다. 제품 $i$ 의 지역별 목표 판매량은 정확히 $\\frac{d_i}{2}$ 이다.\n",
"\n",
"최적화 조건 또는 타당성 제약 조건에 따르면, 지역 A에 배정된 총 판매량은 모든 제품에 대한 총 수요의 절반과 정확히 일치해야 한다:\n",
"\n",
"$A x = \\frac{1}{2} A \\mathbf{1} = b.$\n",
"\n",
"실제로는 정확한 나눗셈이 거의 불가능하기 때문에, 이 문제는 제약 조건 위반의 제곱을 최소화하는 방식으로 정립됩니다(비용 함수):\n",
"\n",
"$\\min_{x} \\left\\Vert{} A x - b \\right\\Vert{}^2 = \\sum_{i=1}^{m} \\left( \\sum_{j=1}^{n} A_{ij} x_j - b\\right)^2.$\n",
"\n",
"이를 전개하면, 제약 조건이 없는 2진 2차 최적화(QUBO) 문제와 동등한 형태가 됩니다.\n",
"\n",
"해결이 완료되면, 해 벡터 $x$ 에 따라 시장이 어느 영역에 할당되는지가 결정됩니다. 이 구성은 제품 수요를 가능한 한 가장 균형 있게 분배할 수 있게 해줍니다.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "55b94021",
"metadata": {},
"source": [
"\n",
"\n",
"## 요구사항\n",
"\n",
"이 튜토리얼을 시작하기 전에 다음 항목이 설치되어 있는지 확인하십시오:\n",
"\n",
"* Qiskit Functions Catalog IBM 클라이언트 (`pip install qiskit-ibm-catalog`)\n",
"* Qiskit 애드온 Optimization Mapper (`pip install qiskit_addon_opt_mapper`)\n",
"* NumPy (`pip install numpy`)\n",
"\n",
"또한 ‘ ParityQC ’ Twine Optimizer 함수를 사용하려면 권한이 필요합니다. 접근 권한을 요청하려면 이 [양식을](https://parityqc.com/products/parity-twine-optimizer/free-trial) 작성해 주십시오.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "7db2e559",
"metadata": {},
"source": [
"\n",
"\n",
"## 설정\n",
"\n",
"(이 코드는 사용자가 이미 [계정을](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) 로컬 환경에 저장해 두었다고 가정합니다.)\n",
"\n",
"먼저, 이 튜토리얼에 필요한 모든 패키지를 가져옵니다.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bc380c46",
"metadata": {},
"outputs": [],
"source": [
"import tempfile\n",
"\n",
"from collections.abc import Callable\n",
"from pathlib import Path\n",
"\n",
"import numpy as np\n",
"import requests\n",
"\n",
"from qiskit_addon_opt_mapper import OptimizationProblem\n",
"from qiskit_addon_opt_mapper.converters import OptimizationProblemToQubo\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog"
]
},
{
"cell_type": "markdown",
"id": "d59c6bf33095b413",
"metadata": {},
"source": [
"Qiskit Functions 카탈로그에서 Parity Twine Optimizer를 불러옵니다:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "805c80a1180e79fe",
"metadata": {},
"outputs": [],
"source": [
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"function = catalog.load(\"parityqc/parity-twine-optimizer\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "988ee237",
"metadata": {},
"source": [
"\n",
"\n",
"### 1단계: 문제를 목적 함수로 정의하기\n",
"\n",
"다음과 같이 [QOBLIB(양자 최적화 벤치마킹 라이브러리)](https://github.com/ZIB-AOPT/QOBLIB) 에서 시장 분할 문제 예제를 가져옵니다.\n",
"\n",
"이 `load_market_split_problem` 함수는 QOBLIB에서 지정된 문제를 가져와 이를 QUBO 문제로 변환합니다.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2a90bce6-1925-436f-a167-4fab3255f4a0",
"metadata": {},
"outputs": [],
"source": [
"def load_market_split_problem(instance_name: str) -> OptimizationProblem:\n",
" \"\"\"Load and formulate a market split optimization problem from an QOBLIB instance.\n",
"\n",
" The QOBLIB library can be found here:\n",
" https://github.com/ZIB-AOPT/QOBLIB.\n",
"\n",
" Args:\n",
" instance_name: Name of the market split instance to load as specified by the .dat file\n",
" in the QOBLIB repo.\n",
"\n",
" Returns:\n",
" The output OptimizationProblem containing the loaded market split problem.\n",
" \"\"\"\n",
"\n",
" problem_matrix, problem_vector = fetch_and_parse(\n",
" instance_name, \"01-marketsplit\", parse_marketsplit_dat\n",
" )\n",
"\n",
" # Create optimization problem\n",
" optimization_problem = OptimizationProblem(instance_name)\n",
"\n",
" # Add binary variables (one for each market)\n",
" optimization_problem.binary_var_list(problem_matrix.shape[1])\n",
"\n",
" # Add equality constraints (one for each product)\n",
" for idx, rhs in enumerate(problem_vector):\n",
" optimization_problem.linear_constraint(\n",
" problem_matrix[idx, :], sense=\"==\", rhs=rhs\n",
" )\n",
"\n",
" # Convert to QUBO with penalty parameter\n",
" return OptimizationProblemToQubo(penalty=1).convert(optimization_problem)"
]
},
{
"cell_type": "markdown",
"id": "becd6460-8eb9-4796-8a21-60d6edc56cd1",
"metadata": {},
"source": [
"이 `load_market_split_problem` 함수는 QOBLIB에서 시장 분할 문제 데이터를 가져와 처리하기 위해 다음과 같은 파서 함수들이 필요합니다.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c07d1d1b-3dc1-4fd8-b7cd-b7898e974eee",
"metadata": {},
"outputs": [],
"source": [
"def fetch_and_parse(instance_name: str, problem: str, parse_func: Callable):\n",
" \"\"\"Generic function to fetch and parse data from QOBLIB repository.\n",
"\n",
" Args:\n",
" instance_name: Name of the instance to fetch.\n",
" problem: Category of the problem (e.g., '01-marketsplit', '07-independentset').\n",
" parse_func: Function used to parse the downloaded file\n",
" (e.g., parse_marketsplit_dat, parse_gph_file).\n",
"\n",
" Returns:\n",
" Result of `parse_func` - either (np.ndarray, np.ndarray) for marketsplit\n",
" or nx.Graph for MIS.\n",
" \"\"\"\n",
" base_url = (\n",
" \"https://raw.githubusercontent.com/ZIB-AOPT/QOBLIB/refs/heads/main/\"\n",
" )\n",
" url = (\n",
" base_url\n",
" + problem\n",
" + \"/instances/\"\n",
" + instance_name\n",
" + (\".dat\" if problem == \"01-marketsplit\" else \".gph\")\n",
" )\n",
"\n",
" try:\n",
" response = requests.get(url, timeout=30)\n",
" response.raise_for_status()\n",
"\n",
" with tempfile.NamedTemporaryFile(\n",
" mode=\"w\",\n",
" suffix=\".dat\" if problem == \"01-marketsplit\" else \".gph\",\n",
" delete=False,\n",
" encoding=\"utf-8\",\n",
" ) as temp_file:\n",
" temp_file.write(response.text)\n",
" temp_file_path = temp_file.name\n",
"\n",
" try:\n",
" return parse_func(temp_file_path)\n",
" finally:\n",
" Path(temp_file_path).unlink(missing_ok=True)\n",
"\n",
" except requests.RequestException as e:\n",
" print(f\"Error fetching data from repository: {e}\")\n",
" except (ValueError, OSError) as e:\n",
" print(f\"Error processing data: {e}\")\n",
" return None\n",
"\n",
"\n",
"def parse_marketsplit_dat(filename: str) -> tuple[np.ndarray, np.ndarray]:\n",
" \"\"\"Parse a market split problem from a .dat file format.\n",
"\n",
" Args:\n",
" filename: Path to the .dat file.\n",
"\n",
" Returns:\n",
" Tuple of (A, b) where:\n",
" - A: (m, n) array of coefficients.\n",
" - b: (m,) array of target values.\n",
"\n",
" Raises:\n",
" ValueError: If file format is invalid or file is empty.\n",
" \"\"\"\n",
" with Path(filename).open(encoding=\"utf-8\") as f:\n",
" lines = [\n",
" line.strip()\n",
" for line in f\n",
" if line.strip() and not line.startswith(\"#\")\n",
" ]\n",
"\n",
" if not lines:\n",
" raise ValueError(\"Empty or invalid .dat file\")\n",
"\n",
" # First line: m n (number of products and markets)\n",
" try:\n",
" m, n = map(int, lines[0].split())\n",
" except (ValueError, IndexError) as e:\n",
" raise ValueError(\n",
" \"Invalid file format: first line must contain 'm n' integers\"\n",
" ) from e\n",
"\n",
" if len(lines) < m + 1:\n",
" raise ValueError(\n",
" f\"File contains {len(lines)} lines but expected {m + 1} lines\"\n",
" )\n",
"\n",
" # Next m lines: each row of A followed by corresponding element of b\n",
" mat_a = []\n",
" vec_b = []\n",
"\n",
" for i in range(1, m + 1):\n",
" try:\n",
" values = list(map(int, lines[i].split()))\n",
" except ValueError as e:\n",
" raise ValueError(f\"Invalid integer values in line {i + 1}\") from e\n",
"\n",
" if len(values) != n + 1:\n",
" raise ValueError(\n",
" f\"Line {i + 1} contains {len(values)} values but expected {n + 1}\"\n",
" )\n",
"\n",
" mat_a.append(values[:-1]) # First n values: product sales per market\n",
" vec_b.append(values[-1]) # Last value: target sales for this product\n",
"\n",
" return np.array(mat_a), np.array(vec_b)"
]
},
{
"cell_type": "markdown",
"id": "9811ef6c-717e-4033-963d-3fd85790be23",
"metadata": {},
"source": [
"한 번 정의되면, 를 사용하여 라이브러리에서 특정 문제 인스턴스를 불러올 `load_marketsplit_problem` 수 있습니다:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "287f6c52-9b2a-46b7-994d-7005bd4ab1c6",
"metadata": {},
"outputs": [],
"source": [
"ms_instance = \"ms_04_050_001\"\n",
"\n",
"ms_problem = load_market_split_problem(ms_instance)"
]
},
{
"cell_type": "markdown",
"id": "ac6f36e3",
"metadata": {},
"source": [
"\n",
"\n",
"### 2단계: JSON 형식으로 변환하기\n",
"\n",
"첫 번째 단계에서, 여러분은 이 문제의 QUBO 형태를 구했습니다. 이제 최적화 함수를 위해 이를 JSON 형식으로 변환해 보겠습니다:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fe1169b1-50a0-4edb-9db5-7c0d99ce9a68",
"metadata": {},
"outputs": [],
"source": [
"def optimization_problem_to_json(\n",
" problem: OptimizationProblem,\n",
") -> dict[str, float]:\n",
" \"\"\"\n",
" Converts an unconstrained quadratic OptimizationProblem in terms of binary or spin variables\n",
" to the JSON input format of the Parity Twine Qiskit Function.\n",
"\n",
" Args:\n",
" problem: The optimization problem to convert to JSON.\n",
"\n",
" Returns:\n",
" The JSON input format of the given problem.\n",
" \"\"\"\n",
" ising, constant = problem.to_ising()\n",
" output = {\"()\": float(constant)}\n",
" for op, coefficient in zip(ising.paulis, ising.coeffs, strict=True):\n",
" # Invert the label strings because Qiskit has opposite convention\n",
" qubits = tuple(\n",
" num\n",
" for num, pauli in enumerate(op.to_label()[::-1])\n",
" if pauli == \"Z\"\n",
" )\n",
" output[str(qubits)] = float(coefficient)\n",
" return output"
]
},
{
"cell_type": "markdown",
"id": "9e374de6-384a-497e-bcf1-c8617c1945ec",
"metadata": {},
"source": [
"Market Split 문제의 QUBO 인스턴스는 이제 다음과 같이 JSON 형식으로 변환되었습니다:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4885df90-4d15-4bc7-8130-ec1d9ece7670",
"metadata": {},
"outputs": [],
"source": [
"json_ms_problem = optimization_problem_to_json(ms_problem)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "b4d480b3",
"metadata": {},
"source": [
"\n",
"\n",
"### 3단계: Parity Twine Optimizer를 사용하여 문제를 해결하세요\n",
"\n",
"이제 시장 분할 문제를 파악하고 올바른 형태로 변환했으므로, Twine Optimizer와 선택한 IBM® 백엔드를 사용하여 해를 구할 수 있습니다.\n",
"\n",
"함수를 실행하려면 적절한 백엔드 장치를 선택하십시오. 예를 들어, `ibm_phoenix`.\n",
"\n",
"제출 과정을 (선택적으로) 추가로 제어하려면 `options` 다음을 사용할 수 있습니다:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a3eaff0a-9c54-4ffc-b6b2-5d43c49e6a07",
"metadata": {},
"outputs": [],
"source": [
"options = {\n",
" \"shots\": 100000,\n",
" \"postprocessing_level\": 1,\n",
" \"transpile_only\": False,\n",
" \"job_tags\": [\"market_split\"],\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "864629a2-34fe-473b-b9f1-277e0a99752d",
"metadata": {},
"source": [
"여기서 `shots` 는 회로 실행 횟수를 나타내는 정수이며, 는 결과에 후처리가 적용되는지 여부를 결정하고 `postprocessing_level` ,\n",
"`transpile_only`는 문제가 회로로만 변환(트랜스파일)되고 해결되지는 않는지 여부를 나타내며, 는 IBM Quantum® Platform 에서 작업을 식별하는 데 사용되는 라벨입니다 `job_tags` .\n",
"\n",
"최적화 도구를 실행합니다:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2c4a5ce3de728746",
"metadata": {},
"outputs": [],
"source": [
"function_job = function.run(\n",
" problem=json_ms_problem,\n",
" variable_type=\"spin\",\n",
" backend_name=\"ibm_phoenix\",\n",
" options=options,\n",
")\n",
"print(f\"Job ID: {function_job.job_id}\")"
]
},
{
"cell_type": "markdown",
"id": "e8e66a1efeef3757",
"metadata": {},
"source": [
"작업 상태 확인:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "be7bbe053da38198",
"metadata": {},
"outputs": [],
"source": [
"# Monitor the job status\n",
"function_job.status()"
]
},
{
"cell_type": "markdown",
"id": "fe4ea9784df0bcbb",
"metadata": {},
"source": [
"결과 가져오기:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9af5dddb30694451",
"metadata": {},
"outputs": [],
"source": [
"# Retrieve the job result if the status is DONE\n",
"result = function_job.result()\n",
"\n",
"result"
]
},
{
"cell_type": "markdown",
"id": "8b888ac0-c0eb-4849-be0d-4bf331707df5",
"metadata": {},
"source": [
"결과는 다음과 같은 형태입니다:\n",
"\n",
"```\n",
"{\n",
" 'solution': {'0': 1, '1': -1, '10': 1, ... },\n",
" 'objective_value': 1.0,\n",
" 'solution_bitstring': '010000011101111011001001110010',\n",
" 'metadata': {\n",
" 'circuit_metrics': {\n",
" 'depth': 309,\n",
" 'gate_count': 3880,\n",
" 'two_qubit_gate_depth': 116,\n",
" 'two_qubit_gate_count': 899,\n",
" 'num_qubits': 30,\n",
" 'operations': {'sx': 1244, 'rz': 1227, 'cz': 899, 'delay': 473, 'measure': 30, 'x': 7},\n",
" },\n",
" 'solver_info': {\n",
" 'variable_mapping': {'0': 0, '1': 1, '10': 2, ... },\n",
" 'bitstring_distributions': {\n",
" 'before_postprocessing': {'011101110010110111001110011000': 1, ...},\n",
" 'after_postprocessing': {'011011110000110101001111011000': 1, ...}\n",
" },\n",
" 'best_parameters': {\n",
" 'beta': [-0.18054534155552715],\n",
" 'gamma': [1.4141236348317905]\n",
" }\n",
" },\n",
" 'resource_usage': {\n",
" 'RUNNING: MAPPING': {'CPU_TIME': 172.936},\n",
" 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 0.272},\n",
" 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 7.798},\n",
" 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 30.0},\n",
" 'RUNNING: POST_PROCESSING': {'CPU_TIME': 31.613},\n",
" },\n",
" }\n",
"}\n",
"```\n",
"\n",
"여기서 이 사전은 `solution` 문제에서 정의된 큐비트에 대응하며, 각 큐비트의 최적화된 스핀 값을 나타낸다.\n",
"`metadata` 트랜스필레이션(2-큐비트 게이트 수/깊이, 사용된 게이트, 활성 큐비트) 및 다양한 실행 시간에 대한 정보를 제공합니다.\n",
"\n",
"시장 분할 문제의 맥락에서, 해 비트스트링은 시장을 두 개의 별도 영역으로 분할하는 데 사용되는 이진 할당 벡터를 나타냅니다. 값이 1이면 해당\n",
"시장이 지역 A에 배정되고, 값이 0이면 지역 B에 배정됩니다. 최적의 해에서는 두 지역 간의 배분이 균형을 이루며, 즉 모든 제품에 대해 두 지역이 회사 전체\n",
"수요의 정확히 절반씩을 받게 됩니다.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "2cb5785c",
"metadata": {},
"source": [
"\n",
"\n",
"## 다음 단계\n",
"\n",
"\n",
" * 이 [양식을](https://parityqc.com/products/parity-twine-optimizer/free-trial) 작성하여 해당 기능에 대한 접근 권한을 요청해 주십시오.\n",
" * 이 Qiskit 함수에 대한 [API 참조](/docs/api/functions/parity-twine-optimizer) 를 확인해 보세요.\n",
" * [가이드를](/docs/guides/parity-twine-optimizer) 읽어보세요.\n",
" * Sherrington-Kirkpatrick 모델에 Parity Twine Optimizer를 적용하는 방법에 대한 [튜토리얼](/docs/tutorials/parity-twine-optimizer-sk) 을 확인해 보세요.\n",
" * [Drier 외 (2025)의](https://arxiv.org/abs/2501.14020) “연결성을 고려한 양자 알고리즘 합성(Connectivity-aware Synthesis of Quantum Algorithms)” ArXiv 사전 출판본을 검토해 보십시오.\n",
"\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
}