From 79fd5de391feded436fbb8a8ae67da5c653fdc68 Mon Sep 17 00:00:00 2001 From: Mahfuza Humayra Mohona Date: Mon, 9 Jun 2025 08:13:42 +0600 Subject: [PATCH 1/2] add sympy tutorial --- examples/demo_sympy_interface.ipynb | 3197 +++++++++++++++++++++++++++ 1 file changed, 3197 insertions(+) create mode 100644 examples/demo_sympy_interface.ipynb diff --git a/examples/demo_sympy_interface.ipynb b/examples/demo_sympy_interface.ipynb new file mode 100644 index 0000000..5b4ee4b --- /dev/null +++ b/examples/demo_sympy_interface.ipynb @@ -0,0 +1,3197 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6ca6ee48", + "metadata": {}, + "source": [ + "# A Friendly Guide to Combining scqubits and sympy for Quantum Circuit Analysis\n", + "\n", + "Hey there! Welcome to this fun and exciting tutorial where we’ll dive into the world of quantum circuits using two awesome Python tools: **scqubits** and **sympy**. Whether you’re just starting out or already have some experience, this guide will walk you through how to use these libraries together to explore superconducting quantum systems, like qubits, in a way that’s both powerful and easy to understand.\n", + "\n", + "## Why Combine scqubits and sympy?\n", + "\n", + "- **scqubits**: Think of scqubits as your quantum lab. It’s a Python library that lets you simulate superconducting qubits numerically, meaning you can plug in numbers to calculate things like energy levels or transition frequencies.\n", + "- **sympy**: Sympy is like a math wizard. It allows you to work with symbols (like variables in algebra) instead of specific numbers, so you can derive general formulas and explore relationships between parameters.\n", + "\n", + "By blending these two, we can simulate quantum systems with numbers (using scqubits) and understand their behavior with equations (using sympy). It’s like having a calculator and a chalkboard working together to unlock deeper insights!\n", + "\n", + "Don’t worry if this sounds a bit complex—we’ll go step by step, and by the end, you’ll be amazed at what you can do!\n" + ] + }, + { + "cell_type": "markdown", + "id": "9ba145b9", + "metadata": {}, + "source": [ + "\n", + "## Getting Started: Installation\n", + "\n", + "Before we jump in, let’s make sure you have the tools you need. You’ll need to install `scqubits` and `sympy`. It’s super easy! If you’re using a Jupyter notebook, just run this command:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "034e99c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: scqubits in /home/mona/.local/lib/python3.10/site-packages (4.3.1)\n", + "Requirement already satisfied: sympy in /home/mona/.local/lib/python3.10/site-packages (1.14.0)\n", + "Requirement already satisfied: cycler in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (0.12.1)\n", + "Requirement already satisfied: dill in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (0.4.0)\n", + "Requirement already satisfied: pathos>=0.3.0 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (0.3.4)\n", + "Requirement already satisfied: matplotlib>=3.5.1 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (3.10.1)\n", + "Requirement already satisfied: numpy>=1.14.2 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (2.2.5)\n", + "Requirement already satisfied: qutip>=4.3.1 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (5.2.0)\n", + "Requirement already satisfied: scipy>=1.5 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (1.15.2)\n", + "Requirement already satisfied: tqdm in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (4.67.1)\n", + "Requirement already satisfied: typing_extensions in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (4.13.2)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /home/mona/.local/lib/python3.10/site-packages (from sympy) (1.3.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (1.3.2)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (4.57.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (1.4.8)\n", + "Requirement already satisfied: packaging>=20.0 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (24.2)\n", + "Requirement already satisfied: pillow>=8 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (11.2.1)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (3.2.3)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (2.9.0.post0)\n", + "Requirement already satisfied: ppft>=1.7.7 in /home/mona/.local/lib/python3.10/site-packages (from pathos>=0.3.0->scqubits) (1.7.7)\n", + "Requirement already satisfied: pox>=0.3.6 in /home/mona/.local/lib/python3.10/site-packages (from pathos>=0.3.0->scqubits) (0.3.6)\n", + "Requirement already satisfied: multiprocess>=0.70.18 in /home/mona/.local/lib/python3.10/site-packages (from pathos>=0.3.0->scqubits) (0.70.18)\n", + "Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.7->matplotlib>=3.5.1->scqubits) (1.16.0)\n" + ] + } + ], + "source": [ + "!pip install scqubits sympy" + ] + }, + { + "cell_type": "markdown", + "id": "034cb21f", + "metadata": {}, + "source": [ + "\n", + "If you’re working in a different environment, like a Python script or terminal, copy that command into your terminal or command prompt. This will download and install both libraries, so you’re ready to roll. If they’re already installed, you can skip this step and dive right in!\n", + "\n", + "## Exploring scqubits: Your Quantum Lab\n", + "\n", + "Let’s start with `scqubits`. This library is designed for simulating superconducting qubits, like the Transmon qubit, which is a popular type used in quantum computing. A qubit is like the quantum version of a bit in regular computers, but it has special properties that make it super powerful for quantum calculations.\n", + "\n", + "With scqubits, you can define a qubit by setting its parameters, such as:\n", + "- **Josephson energy (\\(E_J\\))**: Think of this as the strength of a special junction in the qubit.\n", + "- **Charging energy (\\(E_C\\))**: This relates to how much energy it takes to add a charge to the qubit.\n", + "- **Gate charge (\\(n_g\\))**: This controls the qubit’s behavior with an external voltage.\n", + "- **Truncation parameter (\\(n_{cut}\\))**: This sets the size of the quantum system’s mathematical space.\n", + "\n", + "Here’s an example of how to create a Transmon qubit and calculate its energy levels:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5a414d20", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Energy levels: [-45.06331229 -35.3200142 -25.84262677 -16.64359749 -7.737526\n", + " 0.85814084]\n" + ] + } + ], + "source": [ + "import scqubits as scq\n", + "\n", + "# Define a Transmon qubit with specific numerical parameters\n", + "transmon = scq.Transmon(\n", + " EJ=50.0, # Josephson energy in GHz\n", + " EC=0.25, # Charging energy in GHz\n", + " ng=0.0, # Gate charge\n", + " ncut=30 # Truncation parameter for the Hilbert space\n", + ")\n", + "\n", + "# Calculate the energy levels (eigenvalues) of the qubit\n", + "evals = transmon.eigenvals()\n", + "\n", + "print(\"Energy levels:\", evals)" + ] + }, + { + "cell_type": "markdown", + "id": "a9d7fe1d", + "metadata": {}, + "source": [ + "This code sets up a Transmon qubit with \\(E_J = 50\\) GHz and \\(E_C = 0.25\\) GHz, then computes its energy levels. These levels tell us the possible energy states the qubit can have, which is key for understanding how it behaves in a quantum circuit.\n", + "\n", + "One thing to note: scqubits is great for numerical calculations, but it doesn’t handle symbolic parameters (like variables instead of numbers). That’s where sympy comes in, and we’ll explore that next!" + ] + }, + { + "cell_type": "markdown", + "id": "c40c9981", + "metadata": {}, + "source": [ + "## Getting Started with sympy: Your Math Wizard\n", + "\n", + "While scqubits is awesome for crunching numbers, sometimes we want to work with general formulas instead of specific values. That’s where `sympy` shines. Sympy lets you define variables as symbols and perform algebraic operations, like solving equations, taking derivatives, or simplifying expressions.\n", + "\n", + "Let’s try it out by defining the Josephson energy (\\(E_J\\)) and charging energy (\\(E_C\\)) as symbols:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6ff51ea9", + "metadata": {}, + "outputs": [], + "source": [ + "import sympy as sp\n", + "\n", + "# Define symbolic variables for Josephson and charging energies\n", + "EJ, EC = sp.symbols('E_J E_C')" + ] + }, + { + "cell_type": "markdown", + "id": "a8d24bc4", + "metadata": {}, + "source": [ + "Now, let’s use these symbols to define an important property of the Transmon qubit: the **plasma frequency** (\\(\\omega_p\\)). This is like the natural “vibration” frequency of the qubit, and it’s approximately given by the formula:\n", + "\n", + "\\[\n", + "\\omega_p = \\sqrt{8 E_J E_C}\n", + "\\]\n", + "\n", + "Here’s how we can define it in sympy:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d3bb2054", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Symbolic plasma frequency: 2*sqrt(2)*sqrt(E_C*E_J)\n" + ] + } + ], + "source": [ + "# Define the plasma frequency symbolically\n", + "omega_p = sp.sqrt(8 * EJ * EC)\n", + "\n", + "print(\"Symbolic plasma frequency:\", omega_p)" + ] + }, + { + "cell_type": "markdown", + "id": "37a568dc", + "metadata": {}, + "source": [ + "This gives us a general formula for \\(\\omega_p\\), which we can manipulate in all sorts of ways. For example, let’s say we want to know how sensitive the plasma frequency is to changes in \\(E_J\\) and \\(E_C\\). We can do this by taking the partial derivatives:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "79c10d1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sensitivity to EJ (dω_p / dE_J): sqrt(2)*sqrt(E_C*E_J)/E_J\n", + "Sensitivity to EC (dω_p / dE_C): sqrt(2)*sqrt(E_C*E_J)/E_C\n" + ] + } + ], + "source": [ + "# Compute the partial derivatives of omega_p with respect to EJ and EC\n", + "sensitivity_EJ = sp.diff(omega_p, EJ)\n", + "sensitivity_EC = sp.diff(omega_p, EC)\n", + "\n", + "print(\"Sensitivity to EJ (dω_p / dE_J):\", sensitivity_EJ)\n", + "print(\"Sensitivity to EC (dω_p / dE_C):\", sensitivity_EC)" + ] + }, + { + "cell_type": "markdown", + "id": "cea88aad", + "metadata": {}, + "source": [ + "These derivatives tell us how much \\(\\omega_p\\) changes if we tweak \\(E_J\\) or \\(E_C\\), which is super helpful for designing qubits with specific frequencies.\n", + "\n", + "### Visualizing Sensitivities\n", + "\n", + "To better understand these sensitivities, let’s plot how they change as we vary \\(E_J\\), keeping \\(E_C\\) fixed. This will give us a visual sense of which parameter has a bigger impact on the plasma frequency." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5bb7ba29", + "metadata": {}, + "outputs": [ + { + "data": { + "application/pdf": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2025-06-09T08:11:04.575088\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.10.1, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Fix EC to a numerical value, say 0.25 GHz\n", + "EC_fixed = 0.25\n", + "\n", + "# Create numerical functions for sensitivities\n", + "sensitivity_EJ_func = sp.lambdify(EJ, sensitivity_EJ.subs(EC, EC_fixed), 'numpy')\n", + "sensitivity_EC_func = sp.lambdify(EJ, sensitivity_EC.subs(EC, EC_fixed), 'numpy')\n", + "\n", + "# Define a range for EJ\n", + "EJ_range = np.linspace(10, 100, 100)\n", + "\n", + "# Compute sensitivities\n", + "sensitivity_EJ_values = sensitivity_EJ_func(EJ_range)\n", + "sensitivity_EC_values = sensitivity_EC_func(EJ_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(EJ_range, sensitivity_EJ_values, label='dω_p / dE_J', color='blue')\n", + "plt.plot(EJ_range, sensitivity_EC_values, label='dω_p / dE_C', color='orange')\n", + "plt.xlabel('E_J (GHz)')\n", + "plt.ylabel('Sensitivity')\n", + "plt.title('Sensitivities of Plasma Frequency to E_J and E_C (E_C = 0.25 GHz)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5379a173", + "metadata": {}, + "source": [ + "From this plot, we can see that:\n", + "- The sensitivity to \\(E_J\\) decreases as \\(E_J\\) increases, meaning larger \\(E_J\\) values make \\(\\omega_p\\) less sensitive to changes in \\(E_J\\).\n", + "- The sensitivity to \\(E_C\\) remains relatively constant, indicating that changes in \\(E_C\\) have a consistent impact on \\(\\omega_p\\).\n", + "\n", + "This visualization provides deeper insight into how to tune qubit parameters for desired behavior.\n", + "\n", + "## Combining scqubits and sympy: The Best of Both Worlds\n", + "\n", + "Now, let’s bring scqubits and sympy together to analyze quantum circuits in a powerful way. The catch is that scqubits expects numerical values for parameters like \\(E_J\\) and \\(E_C\\), so we can’t directly use symbols in scqubits calculations. But we can use sympy to derive general relationships and then plug in numbers to connect back to scqubits.\n", + "\n", + "Let’s try defining a Transmon qubit with symbolic parameters to see what happens:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "da8bb5df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error: object arrays are not supported\n" + ] + } + ], + "source": [ + "# Try to define a Transmon with symbolic parameters\n", + "try:\n", + " transmon_sym = scq.Transmon(EJ=EJ, EC=EC, ng=0.0, ncut=30)\n", + " evals_sym = transmon_sym.eigenvals()\n", + "except Exception as e:\n", + " print(\"Error:\", e)" + ] + }, + { + "cell_type": "markdown", + "id": "caf08890", + "metadata": {}, + "source": [ + "\n", + "As expected, this doesn’t work because scqubits needs numbers, not symbols, to compute things like eigenvalues. So, instead, we’ll use sympy to work with our symbolic expressions and then substitute numerical values when we need to connect to scqubits or create visualizations.\n", + "\n", + "### Example: Solving for \\(E_J\\)\n", + "\n", + "Suppose we want to design a qubit with a plasma frequency of 5 GHz, and we know \\(E_C = 0.25\\) GHz. We can use our symbolic expression for \\(\\omega_p\\) to find the required \\(E_J\\):" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ad90a6ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Required E_J for ω_p = 5 GHz: [12.5000000000000]\n" + ] + } + ], + "source": [ + "# Set the desired plasma frequency\n", + "desired_omega_p = 5.0 # in GHz\n", + "\n", + "# Set a numerical value for EC\n", + "EC_num = 0.25 # in GHz\n", + "\n", + "# Substitute EC into the plasma frequency expression\n", + "omega_p_with_EC = omega_p.subs(EC, EC_num)\n", + "\n", + "# Solve for EJ to achieve the desired omega_p\n", + "solution = sp.solve(omega_p_with_EC - desired_omega_p, EJ)\n", + "\n", + "print(\"Required E_J for ω_p = 5 GHz:\", solution)" + ] + }, + { + "cell_type": "markdown", + "id": "77b51c55", + "metadata": {}, + "source": [ + "This code uses sympy to solve the equation \\(\\sqrt{8 E_J \\cdot 0.25} = 5\\), giving us the value of \\(E_J\\) needed for the desired frequency. Isn’t that cool? We’re using math to design our qubit!\n", + "\n", + "### Visualizing the Relationship\n", + "\n", + "To get a better sense of how \\(\\omega_p\\) depends on \\(E_J\\), let’s create a plot. We’ll use sympy to turn our symbolic expression into a numerical function and then use matplotlib to visualize it:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6b76a985", + "metadata": {}, + "outputs": [ + { + "data": { + "application/pdf": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2025-06-09T08:11:05.371309\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.10.1, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert the symbolic expression to a numerical function\n", + "omega_p_func = sp.lambdify(EJ, omega_p_with_EC, 'numpy')\n", + "\n", + "# Define a range of EJ values to explore\n", + "EJ_values = np.linspace(10, 100, 100)\n", + "\n", + "# Compute omega_p for these EJ values\n", + "omega_p_values = omega_p_func(EJ_values)\n", + "\n", + "# Create the plot\n", + "plt.plot(EJ_values, omega_p_values, color='green')\n", + "plt.xlabel('E_J (GHz)')\n", + "plt.ylabel('ω_p (GHz)')\n", + "plt.title('Plasma Frequency vs Josephson Energy (E_C = 0.25 GHz)')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "94654dca", + "metadata": {}, + "source": [ + "This plot shows how the plasma frequency changes as we vary \\(E_J\\), with \\(E_C\\) fixed at 0.25 GHz. It’s a great way to visualize the relationship and understand how to tune our qubit for different frequencies.\n", + "\n", + "## Wrapping It Up\n", + "\n", + "Wow, you’ve made it through! In this tutorial, we’ve learned how to combine `scqubits` and `sympy` to analyze quantum circuits in two powerful ways:\n", + "- **Numerically**, using scqubits to simulate qubits with specific parameters.\n", + "- **Symbolically**, using sympy to derive general formulas and explore relationships.\n", + "\n", + "This approach gives you a deeper understanding of how qubits work and helps you design quantum systems with the exact properties you want. Pretty amazing, right?\n", + "\n", + "### What’s Next?\n", + "\n", + "If you’re excited to keep exploring, here are some ideas:\n", + "- Try this method with other qubit types, like Fluxonium or Xmon, in scqubits.\n", + "- Dive deeper into sympy by exploring advanced features, like solving differential equations or working with matrices.\n", + "- Combine symbolic results with scqubits’ parameter sweeps to study how changing multiple parameters affects your system.\n", + "- Check out the official documentation for [scqubits](https://scqubits.readthedocs.io/) and [sympy](https://docs.sympy.org/) for more inspiration.\n", + "\n", + "Keep experimenting—you’re well on your way to becoming a quantum computing pro!\n", + "\n", + "### Tips for Using Jupyter Notebooks\n", + "\n", + "Since we’re using a Jupyter notebook, here are a few tips to make your experience even better:\n", + "- **Run cells in order**: Jupyter lets you run cells in any order, but running them from top to bottom avoids confusion or errors.\n", + "- **Use keyboard shortcuts**: Try `Shift + Enter` to run a cell, `Esc` to enter command mode, and `A` or `B` to add cells above or below.\n", + "- **Check for errors**: A red outline around a cell means there’s an issue—fix it before moving on.\n", + "- **Save often**: Save your notebook regularly to keep your progress safe.\n", + "\n", + "Thanks for joining me on this quantum adventure! Have fun exploring scqubits and sympy!" + ] + }, + { + "cell_type": "markdown", + "id": "359cffbf", + "metadata": {}, + "source": [] + } + ], + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c66b6518fcfbd57bfefb4d08bdc7bc9317c29d2f Mon Sep 17 00:00:00 2001 From: Mahfuza Humayra Mohona Date: Sat, 14 Jun 2025 16:23:01 +0600 Subject: [PATCH 2/2] added small example --- examples/demo_sympy_interface.ipynb | 3819 +++++---------------------- 1 file changed, 638 insertions(+), 3181 deletions(-) diff --git a/examples/demo_sympy_interface.ipynb b/examples/demo_sympy_interface.ipynb index 5b4ee4b..e5499a7 100644 --- a/examples/demo_sympy_interface.ipynb +++ b/examples/demo_sympy_interface.ipynb @@ -1,3197 +1,654 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "6ca6ee48", - "metadata": {}, - "source": [ - "# A Friendly Guide to Combining scqubits and sympy for Quantum Circuit Analysis\n", - "\n", - "Hey there! Welcome to this fun and exciting tutorial where we’ll dive into the world of quantum circuits using two awesome Python tools: **scqubits** and **sympy**. Whether you’re just starting out or already have some experience, this guide will walk you through how to use these libraries together to explore superconducting quantum systems, like qubits, in a way that’s both powerful and easy to understand.\n", - "\n", - "## Why Combine scqubits and sympy?\n", - "\n", - "- **scqubits**: Think of scqubits as your quantum lab. It’s a Python library that lets you simulate superconducting qubits numerically, meaning you can plug in numbers to calculate things like energy levels or transition frequencies.\n", - "- **sympy**: Sympy is like a math wizard. It allows you to work with symbols (like variables in algebra) instead of specific numbers, so you can derive general formulas and explore relationships between parameters.\n", - "\n", - "By blending these two, we can simulate quantum systems with numbers (using scqubits) and understand their behavior with equations (using sympy). It’s like having a calculator and a chalkboard working together to unlock deeper insights!\n", - "\n", - "Don’t worry if this sounds a bit complex—we’ll go step by step, and by the end, you’ll be amazed at what you can do!\n" - ] - }, - { - "cell_type": "markdown", - "id": "9ba145b9", - "metadata": {}, - "source": [ - "\n", - "## Getting Started: Installation\n", - "\n", - "Before we jump in, let’s make sure you have the tools you need. You’ll need to install `scqubits` and `sympy`. It’s super easy! If you’re using a Jupyter notebook, just run this command:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "034e99c3", - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: scqubits in /home/mona/.local/lib/python3.10/site-packages (4.3.1)\n", - "Requirement already satisfied: sympy in /home/mona/.local/lib/python3.10/site-packages (1.14.0)\n", - "Requirement already satisfied: cycler in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (0.12.1)\n", - "Requirement already satisfied: dill in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (0.4.0)\n", - "Requirement already satisfied: pathos>=0.3.0 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (0.3.4)\n", - "Requirement already satisfied: matplotlib>=3.5.1 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (3.10.1)\n", - "Requirement already satisfied: numpy>=1.14.2 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (2.2.5)\n", - "Requirement already satisfied: qutip>=4.3.1 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (5.2.0)\n", - "Requirement already satisfied: scipy>=1.5 in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (1.15.2)\n", - "Requirement already satisfied: tqdm in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (4.67.1)\n", - "Requirement already satisfied: typing_extensions in /home/mona/.local/lib/python3.10/site-packages (from scqubits) (4.13.2)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /home/mona/.local/lib/python3.10/site-packages (from sympy) (1.3.0)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (1.3.2)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (4.57.0)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (1.4.8)\n", - "Requirement already satisfied: packaging>=20.0 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (24.2)\n", - "Requirement already satisfied: pillow>=8 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (11.2.1)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (3.2.3)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /home/mona/.local/lib/python3.10/site-packages (from matplotlib>=3.5.1->scqubits) (2.9.0.post0)\n", - "Requirement already satisfied: ppft>=1.7.7 in /home/mona/.local/lib/python3.10/site-packages (from pathos>=0.3.0->scqubits) (1.7.7)\n", - "Requirement already satisfied: pox>=0.3.6 in /home/mona/.local/lib/python3.10/site-packages (from pathos>=0.3.0->scqubits) (0.3.6)\n", - "Requirement already satisfied: multiprocess>=0.70.18 in /home/mona/.local/lib/python3.10/site-packages (from pathos>=0.3.0->scqubits) (0.70.18)\n", - "Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.7->matplotlib>=3.5.1->scqubits) (1.16.0)\n" - ] - } - ], - "source": [ - "!pip install scqubits sympy" - ] - }, - { - "cell_type": "markdown", - "id": "034cb21f", - "metadata": {}, - "source": [ - "\n", - "If you’re working in a different environment, like a Python script or terminal, copy that command into your terminal or command prompt. This will download and install both libraries, so you’re ready to roll. If they’re already installed, you can skip this step and dive right in!\n", - "\n", - "## Exploring scqubits: Your Quantum Lab\n", - "\n", - "Let’s start with `scqubits`. This library is designed for simulating superconducting qubits, like the Transmon qubit, which is a popular type used in quantum computing. A qubit is like the quantum version of a bit in regular computers, but it has special properties that make it super powerful for quantum calculations.\n", - "\n", - "With scqubits, you can define a qubit by setting its parameters, such as:\n", - "- **Josephson energy (\\(E_J\\))**: Think of this as the strength of a special junction in the qubit.\n", - "- **Charging energy (\\(E_C\\))**: This relates to how much energy it takes to add a charge to the qubit.\n", - "- **Gate charge (\\(n_g\\))**: This controls the qubit’s behavior with an external voltage.\n", - "- **Truncation parameter (\\(n_{cut}\\))**: This sets the size of the quantum system’s mathematical space.\n", - "\n", - "Here’s an example of how to create a Transmon qubit and calculate its energy levels:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "5a414d20", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "6ca6ee48", + "metadata": { + "id": "6ca6ee48" + }, + "source": [ + "# Guide to Combining scqubits and sympy for Quantum Circuit Analysis\n", + "\n", + "Hey there! Welcome to this tutorial where we’ll dive into the world of quantum circuits using two Python tools: **scqubits** and **sympy**. Whether you’re just starting out or already have some experience, this guide will walk you through how to use these libraries together to explore superconducting quantum systems, like qubits, in a way that’s both powerful and easy to understand.\n", + "\n", + "## Why Combine scqubits and sympy?\n", + "\n", + "- **scqubits**: Think of scqubits as your quantum lab. It’s a Python library that lets you simulate superconducting qubits numerically, meaning you can plug in numbers to calculate things like energy levels or transition frequencies.\n", + "- **sympy**: Sympy is like a math wizard. It allows you to work with symbols (like variables in algebra) instead of specific numbers, so you can derive general formulas and explore relationships between parameters.\n", + "\n", + "By blending these two, we can simulate quantum systems with numbers (using scqubits) and understand their behavior with equations (using sympy). It’s like having a calculator and a chalkboard working together to unlock deeper insights!\n", + "\n", + "Don’t worry if this sounds a bit complex—we’ll go step by step, and by the end, you’ll be amazed at what you can do!\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Energy levels: [-45.06331229 -35.3200142 -25.84262677 -16.64359749 -7.737526\n", - " 0.85814084]\n" - ] - } - ], - "source": [ - "import scqubits as scq\n", - "\n", - "# Define a Transmon qubit with specific numerical parameters\n", - "transmon = scq.Transmon(\n", - " EJ=50.0, # Josephson energy in GHz\n", - " EC=0.25, # Charging energy in GHz\n", - " ng=0.0, # Gate charge\n", - " ncut=30 # Truncation parameter for the Hilbert space\n", - ")\n", - "\n", - "# Calculate the energy levels (eigenvalues) of the qubit\n", - "evals = transmon.eigenvals()\n", - "\n", - "print(\"Energy levels:\", evals)" - ] - }, - { - "cell_type": "markdown", - "id": "a9d7fe1d", - "metadata": {}, - "source": [ - "This code sets up a Transmon qubit with \\(E_J = 50\\) GHz and \\(E_C = 0.25\\) GHz, then computes its energy levels. These levels tell us the possible energy states the qubit can have, which is key for understanding how it behaves in a quantum circuit.\n", - "\n", - "One thing to note: scqubits is great for numerical calculations, but it doesn’t handle symbolic parameters (like variables instead of numbers). That’s where sympy comes in, and we’ll explore that next!" - ] - }, - { - "cell_type": "markdown", - "id": "c40c9981", - "metadata": {}, - "source": [ - "## Getting Started with sympy: Your Math Wizard\n", - "\n", - "While scqubits is awesome for crunching numbers, sometimes we want to work with general formulas instead of specific values. That’s where `sympy` shines. Sympy lets you define variables as symbols and perform algebraic operations, like solving equations, taking derivatives, or simplifying expressions.\n", - "\n", - "Let’s try it out by defining the Josephson energy (\\(E_J\\)) and charging energy (\\(E_C\\)) as symbols:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6ff51ea9", - "metadata": {}, - "outputs": [], - "source": [ - "import sympy as sp\n", - "\n", - "# Define symbolic variables for Josephson and charging energies\n", - "EJ, EC = sp.symbols('E_J E_C')" - ] - }, - { - "cell_type": "markdown", - "id": "a8d24bc4", - "metadata": {}, - "source": [ - "Now, let’s use these symbols to define an important property of the Transmon qubit: the **plasma frequency** (\\(\\omega_p\\)). This is like the natural “vibration” frequency of the qubit, and it’s approximately given by the formula:\n", - "\n", - "\\[\n", - "\\omega_p = \\sqrt{8 E_J E_C}\n", - "\\]\n", - "\n", - "Here’s how we can define it in sympy:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d3bb2054", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "9ba145b9", + "metadata": { + "id": "9ba145b9" + }, + "source": [ + "\n", + "## Getting Started: Installation\n", + "\n", + "Before we jump in, let’s make sure you have the tools you need. You’ll need to install `scqubits` and `sympy`. It’s super easy! If you’re using a Jupyter notebook, just run this command:" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Symbolic plasma frequency: 2*sqrt(2)*sqrt(E_C*E_J)\n" - ] - } - ], - "source": [ - "# Define the plasma frequency symbolically\n", - "omega_p = sp.sqrt(8 * EJ * EC)\n", - "\n", - "print(\"Symbolic plasma frequency:\", omega_p)" - ] - }, - { - "cell_type": "markdown", - "id": "37a568dc", - "metadata": {}, - "source": [ - "This gives us a general formula for \\(\\omega_p\\), which we can manipulate in all sorts of ways. For example, let’s say we want to know how sensitive the plasma frequency is to changes in \\(E_J\\) and \\(E_C\\). We can do this by taking the partial derivatives:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "79c10d1a", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "034e99c3", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "034e99c3", + "outputId": "70b9926c-a2f8-4220-d7d9-926104eb4687" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: scqubits in /usr/local/lib/python3.11/dist-packages (4.3.1)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.11/dist-packages (1.13.1)\n", + "Requirement already satisfied: cycler in /usr/local/lib/python3.11/dist-packages (from scqubits) (0.12.1)\n", + "Requirement already satisfied: dill in /usr/local/lib/python3.11/dist-packages (from scqubits) (0.4.0)\n", + "Requirement already satisfied: pathos>=0.3.0 in /usr/local/lib/python3.11/dist-packages (from scqubits) (0.3.4)\n", + "Requirement already satisfied: matplotlib>=3.5.1 in /usr/local/lib/python3.11/dist-packages (from scqubits) (3.10.0)\n", + "Requirement already satisfied: numpy>=1.14.2 in /usr/local/lib/python3.11/dist-packages (from scqubits) (2.0.2)\n", + "Requirement already satisfied: qutip>=4.3.1 in /usr/local/lib/python3.11/dist-packages (from scqubits) (5.2.0)\n", + "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.11/dist-packages (from scqubits) (1.15.3)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from scqubits) (4.67.1)\n", + "Requirement already satisfied: typing_extensions in /usr/local/lib/python3.11/dist-packages (from scqubits) (4.14.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy) (1.3.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (1.3.2)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (4.58.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (1.4.8)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (24.2)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (11.2.1)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (3.2.3)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.5.1->scqubits) (2.9.0.post0)\n", + "Requirement already satisfied: ppft>=1.7.7 in /usr/local/lib/python3.11/dist-packages (from pathos>=0.3.0->scqubits) (1.7.7)\n", + "Requirement already satisfied: pox>=0.3.6 in /usr/local/lib/python3.11/dist-packages (from pathos>=0.3.0->scqubits) (0.3.6)\n", + "Requirement already satisfied: multiprocess>=0.70.18 in /usr/local/lib/python3.11/dist-packages (from pathos>=0.3.0->scqubits) (0.70.18)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib>=3.5.1->scqubits) (1.17.0)\n" + ] + } + ], + "source": [ + "!pip install scqubits sympy" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sensitivity to EJ (dω_p / dE_J): sqrt(2)*sqrt(E_C*E_J)/E_J\n", - "Sensitivity to EC (dω_p / dE_C): sqrt(2)*sqrt(E_C*E_J)/E_C\n" - ] - } - ], - "source": [ - "# Compute the partial derivatives of omega_p with respect to EJ and EC\n", - "sensitivity_EJ = sp.diff(omega_p, EJ)\n", - "sensitivity_EC = sp.diff(omega_p, EC)\n", - "\n", - "print(\"Sensitivity to EJ (dω_p / dE_J):\", sensitivity_EJ)\n", - "print(\"Sensitivity to EC (dω_p / dE_C):\", sensitivity_EC)" - ] - }, - { - "cell_type": "markdown", - "id": "cea88aad", - "metadata": {}, - "source": [ - "These derivatives tell us how much \\(\\omega_p\\) changes if we tweak \\(E_J\\) or \\(E_C\\), which is super helpful for designing qubits with specific frequencies.\n", - "\n", - "### Visualizing Sensitivities\n", - "\n", - "To better understand these sensitivities, let’s plot how they change as we vary \\(E_J\\), keeping \\(E_C\\) fixed. This will give us a visual sense of which parameter has a bigger impact on the plasma frequency." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5bb7ba29", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "034cb21f", + "metadata": { + "id": "034cb21f" + }, + "source": [ + "\n", + "If you’re working in a different environment, like a Python script or terminal, copy that command into your terminal or command prompt. This will download and install both libraries, so you’re ready to roll. If they’re already installed, you can skip this step and dive right in!\n", + "\n", + "## Exploring scqubits: Your Quantum Lab\n", + "\n", + "Let’s start with `scqubits`. This library is designed for simulating superconducting qubits, like the Transmon qubit, which is a popular type used in quantum computing. A qubit is like the quantum version of a bit in regular computers, but it has special properties that make it super powerful for quantum calculations.\n", + "\n", + "With scqubits, you can define a qubit by setting its parameters, such as:\n", + "- **Josephson energy (\\(E_J\\))**: Think of this as the strength of a special junction in the qubit.\n", + "- **Charging energy (\\(E_C\\))**: This relates to how much energy it takes to add a charge to the qubit.\n", + "- **Gate charge (\\(n_g\\))**: This controls the qubit’s behavior with an external voltage.\n", + "- **Truncation parameter (\\(n_{cut}\\))**: This sets the size of the quantum system’s mathematical space.\n", + "\n", + "Here’s an example of how to create a Transmon qubit and calculate its energy levels:" + ] + }, { - "data": { - "application/pdf": "JVBERi0xLjQKJazcIKu6CjEgMCBvYmoKPDwgL1R5cGUgL0NhdGFsb2cgL1BhZ2VzIDIgMCBSID4+CmVuZG9iago4IDAgb2JqCjw8IC9Gb250IDMgMCBSIC9YT2JqZWN0IDcgMCBSIC9FeHRHU3RhdGUgNCAwIFIgL1BhdHRlcm4gNSAwIFIKL1NoYWRpbmcgNiAwIFIgL1Byb2NTZXQgWyAvUERGIC9UZXh0IC9JbWFnZUIgL0ltYWdlQyAvSW1hZ2VJIF0gPj4KZW5kb2JqCjExIDAgb2JqCjw8IC9UeXBlIC9QYWdlIC9QYXJlbnQgMiAwIFIgL1Jlc291cmNlcyA4IDAgUgovTWVkaWFCb3ggWyAwIDAgNjA1Ljc5MDYyNSAzOTIuNzkgXSAvQ29udGVudHMgOSAwIFIgL0Fubm90cyAxMCAwIFIgPj4KZW5kb2JqCjkgMCBvYmoKPDwgL0xlbmd0aCAxMiAwIFIgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicvZpLk1S5EYX391fcJSy4SKn3wothHjhmZQbCXngcE0TTg5mgwQzzCPvX+8tUdV2p+gHtRzcB3XVQ55WOMk8eqerxV+e/vTk7/+7pk/XL58vj/dXZx8WvP/H39erWn/j7++rXp/x9vTheXSzZpa00lyXx8u34MjThRzC3//j3ZflxefwFv/6R4U+XJbotHYaXrfLtYkmtnmBvZ8xtMSs4/u4lZg/4sF4Jm1JdQ5Atx/Xn8/Uv67v18Reis5D1W1bDyrbK2tyWm/Mtu1Ij0zshQmQLvtRW98lO2OUklufLs/XD5RMc3A1PgD2QTwaLW7CVL08g//flA/+69ZEjkvdpa6kmkSIlrBI2CZ6xZxfLkxfL428Y4dYXP9r+vHi1/HV9IO7h+rf1xbfL1y+WZza1/ws/EtLmYvJlX9EI3YWd20PdzI1I3XJNpaXIn8/hJt4PNyGWrRSJMewrmrC7sPOpYDfzE6Lfog8uV8+fz+En3w8/MUNAa8XnfUkTdhd+PhXsZn7Ims1HF6JrrvnP4afeDz+pMBXJrbZBKEfsLvx8KtjN/KQcqK/SJPvAcj6DH+8mgsZabXkra9tSaqHcFuLrH75dv3/w9I//+v7h/eTiMWiSzdfi3Ulb2uHPzMdrAzJjd028q5pWDiTHuoXmJDjJQW7h654q9hjUa88vNaQ80zTgd+VpCrkTNUe8mSnv/Naqj9W7WOotVKX7piq1LWQddkLVjt+ZqjHkQNUU8SpVhCsknQ5MW1In4Wv4RCXfM1niZWNQJehE1oDflawp5E7WHPEWssS1zefQKgJYbqtBf9+ZJTmjpOLdKVk7fmeyxpADWVPE28jKuH5GBtqpv60K78mfDkGZpI8hpHZy3tjxu5I1hdzJmiPeQlbweQsxxxp9zbea+TT3Uw3zSAP6yBlLOyknCB5fb+/Lz8/ffXzzy5vf3vzyz/+efL8lI0Xn8t0p7UvW80qkYlbcVaqhFOWo+I1dwrArilKXqKJe8iZOfEuKhkaRRdDqcSTZZzGUA5AonTVvMTnPz6ASWmw6tjGZgn/LihI1iCiayYzqcjDUR/U5bxftE0zBGeqyy8UbmrcWE2bRYG8S6pEIl1uDgxQQi5gkG1w230IL3mDx2eLuBznQitV2HS5b7PurcIzJ0sJDbcoQIwYz9WzTgP1cW2lN4VLUdykcZav8Xw8Ca87ZRPD/7H7pQbC51eyg54WDuR6EcMHAiuFIOWcDM1M1GHMXeHoIBocacofrRgb3sTwmK8v8BiJQUi4Kp6b7qKgev3imkZSK66d3OgvLSuyVwcmFA1xhrMVsLKXgSmepQTohgi0wed+8LbAhvYWdtQXGFmpTlsSREQ43agtkdqmKwW2Lkg7T1s2MuhahSBK/62yJHJZ04xRuW4Y6W0yUmgwULagioaNqeC2yNN1nnqtwaKxAp7cfTxWtKfbB1BLk+x4jFHGpw2kTHn2IkZp3BidcvC+uGE+ogdKrMB06eheMJ9Q0Gn3CiSbn5JzxRJpna19820olb4wnioWHKcwJoVErwXgKzvVMFQrOQZ4znqS26G00FedpiMV4EjI52yIpOalolKG59rQWSi46XtgiJfUkU3ufoLT0wZDudTHs1abrirZGqrbZrDmSMmsyoHbYVdsvpr81F3OxNQr7lA1FX5lLtCWKDzaUmkMY8iGCizV1GFNIVvQIXmtLqVY5i1DXQ5CJKds0qLkEYa51mK3QbA9Rxa+SXQaX4KI3+HjmVjin1CeNn4ewvkJqTXoMis4hNaV0WK2pwhSdJ0I0mviJ3TC4KsGs3+BQSH2Fi6acsCEdhhpbDXWXkMfYFymhVlsNdZcpGN8XiRgmQ+tGEfvS18iXpSqlgFJhmvsaXWymQmwQEije2xppK80Fu3tDRsOBbKc10NHGrJ3rMUgfTXxgqi5UTECPwTPERlN1yZUukq6kanUeKTsUqcXSYRe8DabsMBPNG08ux+Z1ehBHB23M2+B0MLzQuDkKJvbY7EurBifYKSiUwbGR5wpTd0LpVukw9RUNTpQszcSIcqoVNpP9JsFggtojqbss7FtfJIxUG03dlXhQayeHxhNL0safu1xYWtjgSpE22m1fpLeeoHBmn8D7Ir2dvYGpO0EmfV8k3clymI3D+Rfyv8PSdQv1Zdo+ahDcbqvB5pcovOyRl9phNkVR6q6w4Jo6SnCLgUmp9AdETOGKrOqWYQZ5wQmidRipttGUHtlFoRpMeVvGIwoUeEKcOxxt2xOVF7SPdNBZTVOeWANOJsVQ1M5Ofom6Y5+ZdYeFE6HCvCgqeH2F5IrJJ21qqzSd2leYUjJ5T1mf02hLHfYsx2B6o+OM3SdC0ZtODtcjBg9H///ULnl1q6RHqhU6sGbfPV1vdE6cZTWNSdnJOiF4SDy9Xibv5BPWiOFWwbt5QtFpH5RInNyTz1rL0FQm+wR7dG11DqN98jw85BSsQnb/hLbwk0smroOBUkeg7se0ePBQnllF1pNPTJSvVH/MwQRisFGkAKKFKSizj/INB61SWmYjRTiat+9ta3BSXi+dqKXusHYrpe6CdXvrUYOXglCkyxfT+8FMsVRV5WpiPfgpcZBGjYU2GyqOS2gdhSajo6J1qVof7NduqcQn5Tv4OJsq8XQFLb8wuyq2gMzHwPrZVoloy4NGP/sqEeKzDlOXwVjp9blzzdcTZ0U/1suEPp/BWolmucqAzN5KUOWmOhAnc4WVoj1Q43m2V7gA2pcU85CDv5KICiGkZTZYaB4jXOs2Y3dYErP2nGQHicFiSVTWVE1nj6U/hngoh8FkCUUVY7aaGkyW6OmFxVj/G1yWUGypZG8yNtgsjBAq1XorHnyWhaRF9/G70dLjcib/7QyyOy3kG32hgeXZak3H8MFsiSYXBNo0B7elM6MRV8vAwW5BO/rgqvXNwW8JFU2UaDk1OC5bSTUlmkwXD6foSYIyuy4pNO5Kn8+z7dKVZyq2x999F2JOenHYOTFeuHJV4NjN3u68BGVAxg5xjtZL1OVwxGp+9l6CYGAHcqdnN1/SRO1vtRwc3Jdo1ZDPMc72SxoJEGOx0hr8lzS0KXFyPTFgolVGktcyWzCc+MaR2FmXGTwYHUjPPtF8y2DCgrNTbbXl7i4soEdViu82Z7dhHKo2lKB2fPdhQS+yOAS4Ohkx6oWK4zRSZicWUO5AH7a+N1gxHBFKKSWdeLGAgKFSzQ4qgxnTPPJoljmSwY0RGo3gS2Y7ptcnVHipsx0LGI7CvPo0h3d2RM9HrRiZgyELojPLrhu1oyOjLZKNbOqJJdPsZZebmY3BkwUWTv5VS/3BlAXksdEUrbQGV2bZThK1E1sWAqyx+Sangy9D2UmvXE0fB2OG1GK70Po8WzOmorvSc3DwZlBA7utl0GzO9N0/JcSX2Z1ZlVEsJ+6MpGcECRonfxaiKqXrTWhwaJxX8WLe293MYNGCvm9RVJJmj4b0MkuvLmEyaVBHN6WWZHZpWtvobLBWP9i0YPcxodoJZHwbS/MlXn2PRl3Yfot34xXh8Y3Daz5lQMCrn1K4uP5TCoz9zA85nIzsAW6O6nQdh1tJb6t5PX1MQO8WaXr997L93nAdKMN14Hwf+Ob84/r+x/VPb19+vHi5fvNwLSrUEVulX+uDnx/atWW4/FoenH/49fzd2T/XX96v+l7dy3ev+P7l+v0D/fcPq1bzevn23XJ50/j4i6C7cfxkCTvSP1dCJR7Xq4Yu6fXoBaYMFYl6v7mjatWwo4U+FgZYfd3lUE0HiqhMYDwMPFsGlF7QuR0x9Si61HV8EMKiI4cZHZCzce4HTIUIAvAxcsS0gi5HHZ8wguEy3I4dJ/12Qo/rG55yJOI6Js/0MzJPlltvcE+roh3DUKah+EMKX0XfLvladErX/fp8SNeyT1UvQcvtt9evDnfW+//p7bdwZEE+SzqO++Ef6+P1FUm533F/INWct6XaD3rtTjPoH2A6u1gJ+eir859e/vnX5y/ffXz0/uL89cv1q/frM3LW2Lrm8LZec3gbSFON9PUKazs80TbCd+KNbtD8J67970rcl/8b4p4t/wYfI9XXCmVuZHN0cmVhbQplbmRvYmoKMTIgMCBvYmoKMzA0MQplbmRvYmoKMTAgMCBvYmoKWyBdCmVuZG9iagoxNyAwIG9iago8PCAvTGVuZ3RoIDIzNSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw1UUluADEIu+cV/kClsCfvmarqof3/tYZRLwMD2Ngk78FGJD7EkO4oV3zK6jTL8DtZ5MXPSuHkvYgKpCrCCmkHz3JWMwyeG5kClzPxWWY+mRY7FlBNxHF25DSDQYhpXEfL6TDTPOgJuT4YcWOnWa5iSOvdUr2+1/KfKspH1t0st07Z1ErdomfsSVx2Xk9taV8YdRQ3BZEOHzu8B/ki5iwuOpFu9psph5WkITgtgB+JoVTPDq8RJn5mJHjKnk7vozS89kHT9b17QUduJmQqt1BGKp6sNMaMofqNaCap7/+BnvW9vv4AQ01UuQplbmRzdHJlYW0KZW5kb2JqCjE4IDAgb2JqCjw8IC9MZW5ndGggODEgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTc27DcAgDATQnik8AuD/PlGUItm/jQ0RobGfdCedYIcKbnFYDLQ7HK341FOYfegeEpJQc91EWDMl2oSkX/rLMMOYWMi2rzdXrnK+FtwciwplbmRzdHJlYW0KZW5kb2JqCjE5IDAgb2JqCjw8IC9MZW5ndGggNzYgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicMzU3VTBQsLQAEqaG5grmRpYKKYZcQD6IlcsFE8sBs8xMzIAsQ0tklomxIZBlYmGGxDI2sYDKIlgGQBpsTQ7M9ByuDK40ADUXGQUKZW5kc3RyZWFtCmVuZG9iagoyMCAwIG9iago8PCAvTGVuZ3RoIDI0NyAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxNUUluxDAMu/sV/MAAlqzFeU+KQQ/t/68lHRTtwRAjS1zi7sREFl62UNdCh+PDRl4Jm4Hvg9ac+Bqx4j/aRqSVP1RbIBMxUSR0UTca90g3vArRfqSCV6r3WPMRdyvNWzp2sb/3wbTmkSqrQjzk2BzZSFrXRNHxPbTec0N0yiCBPjchB0Rpjl6FpL/2w3VtNLu1NrMnqoNHpoTySbMamtMpZshsqMdtKlYyCjeqjIr7VEZaD/I2zjKAk+OEMlpPdqwmovzUJ5eQFxNxwi47OxZiEwsbh7QflT6x/Hzrzfibaa2lkHFBIjTFpd9nvMfneP8AlU9cJgplbmRzdHJlYW0KZW5kb2JqCjIxIDAgb2JqCjw8IC9MZW5ndGggNzkgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicMzc1UjBQsLQAEmamJgrmRpYKKYZcQD6IlctlaGkOZuWAWSbGBkCWqakpEgsiC9MLYcHkYLSxiTnUBAQLJAe2NgdmWw5XBlcaANaUHAwKZW5kc3RyZWFtCmVuZG9iagoyMiAwIG9iago8PCAvTGVuZ3RoIDExNSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw9jksSAyEIBfec4l3AKsEgcp5JpbIw998O6JgVzacBcUVFUUZhd7AbTBxvJh+LfnRqc1FMbiitg0e4qb0i5+a4iLkFmqPXvbKsgmfvf2Y+yD1R6kGRTZpKbbAYsjRH7FFF/BT9DKFf58VJX/rc5g8l4QplbmRzdHJlYW0KZW5kb2JqCjIzIDAgb2JqCjw8IC9MZW5ndGggMTcwIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD2QSxLDIAxD95xCRwD/gPO00+mC3H9by5l0gxRjyy9EV3TslYfHxpSN92hjT4QtXOV0Gk5TGY+Lu2ZdoMthMtNvvJq5wFRhkdXsovoYvKHzrGaHr1UzMYQ3mRIaYCp3cg/19ac47duSkGxXYdCdGqSzMMyR/D0QU3PQc4iR/CNfcmth0JnmFxctqxmtZUzR7GGqbC0M6o1Bd8r11Hqu8zAR7/MD30E+ZAplbmRzdHJlYW0KZW5kb2JqCjI0IDAgb2JqCjw8IC9MZW5ndGggMzQxIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDVSO9KbQQjrv1PoAp5Z3st5nMmk+HP/NgI7FSywQgLSAgeZeIkhqlGu+CVPMF4n8He9PI2fx7uQWvBUpB+4Nm3j/VizJgqWRiyF2ce+HyXkeGr8GwI9F2nCjExGDiQDcb/W5896kymH34A0bU4fJUkPogW7W8OOLwsySHpSw5Kd/LCuBVYXoQlzY00kI6dWpub52DNcxhNjJKiaBSTpE/epghFpxmPnrCUPMhxP9eLFr7fxWuYx9bKqQMY2wRxsJzPhFEUE4heUJDdxF00dxdHMWHO70FBS5L67h5OTXveXk6jAKyGcxVrCMUNPWeZkp0EJVK2cADOs174wTtNGCXdqur0r9vXzzCSM2xx2VkqmwTkO7mWTOYJkrzsmbMLjEPPePYKRmDe/iy2CK5c512T6sR9FG+mD4vqcqymzFSX8Q5U8seIa/5/f+/nz/P4HjCh+IwplbmRzdHJlYW0KZW5kb2JqCjI1IDAgb2JqCjw8IC9MZW5ndGggMzA3IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD2SS24DMQxD9z6FLhDA+tme86Qoupjef9snJemKHNkWRWqWukxZUx6QNJOEf+nwcLGd8jtsz2Zm4Fqil4nllOfQFWLuonzZzEZdWSfF6oRmOrfoUTkXBzZNqp+rLKXdLngO1yaeW/YRP7zQoB7UNS4JN3RXo2UpNGOq+3/Se/yMMuBqTF1sUqt7HzxeRFXo6AdHiSJjlxfn40EJ6UrCaFqIlXdFA0Hu8rTKewnu295qyLIHqZjOOylmsOt0Ui5uF4chHsjyqPDlo9hrQs/4sCsl9EjYhjNyJ+5oxubUyOKQ/t6NBEuPrmgh8+CvbtYuYLxTOkViZE5yrGmLVU73UBTTucO9DBD1bEVDKXOR1epfw84La5ZsFnhK+gUeo90mSw5W2duoTu+tPNnQ9x9a13QfCmVuZHN0cmVhbQplbmRvYmoKMjYgMCBvYmoKPDwgL0xlbmd0aCAyMzIgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicNVFJbsQwDLv7FfzAANbuvCfFoIf2/9dSyhQIQCW2uCViYyMCLzH4OYjc+JI1oyZ+Z3JX/CxPhUfCreBJFIGX4V52gssbxmU/DjMfvJdWzqTGkwzIRTY9PBEy2CUQOjC7BnXYZtqJviHhsyNSzUaW09cS9NIqBMpTtt/pghJtq/pz+6wLbfvaE052e+pJ5ROI55aswGXjFZPFWAY9UblLMX2Q6myhJ6G8KJ+DbD5qiESXKGfgicHBKNAO7LntZ+JVIWhd3adtY6hGSsfTvw1NTZII+UQJZ7Y07hb+f8+9vtf7D04hVBEKZW5kc3RyZWFtCmVuZG9iagoyNyAwIG9iago8PCAvTGVuZ3RoIDIzMSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw1TzmSBCEMy3mFPjBVGNtAv6entjbY+X+6kplOkPAhydMTHZl4mSMjsGbH21pkIGbgU0zFv/a0DxOq9+AeIpSLC2GGkXDWrONuno4X/3aVz1gH7zb4illeENjCTNZXFmcu2wVjaZzEOclujF0TsY11radTWEcwoQyEdLbDlCBzVKT0yY4y5ug4kSeei+/22yx2OX4O6ws2jSEV5/gqeoI2g6Lsee8CGnJB/13d+B5Fu+glIBsJFtZRYu6c5YRfvXZ0HrUoEnNCmkEuEyHN6SqmEJpQrLOjoFJRcKk+p+isn3/lX1wtCmVuZHN0cmVhbQplbmRvYmoKMjggMCBvYmoKPDwgL0xlbmd0aCAyNDkgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicPVA7jkQhDOs5hS/wJPIjcB5Gqy1m79+uA5opUEx+tjMk0BGBRwwxlK/jJa2groG/i0LxbuLrg8Igq0NSIM56D4h07KY2kRM6HZwzP2E3Y47ARTEGnOl0pj0HJjn7wgqEcxtl7FZIJ4mqIo7qM44pnip7n3gWLO3INlsnkj3kIOFSUonJpZ+Uyj9typQKOmbRBCwSueBkE004y7tJUowZlDLqHqZ2In2sPMijOuhkTc6sI5nZ00/bmfgccLdf2mROlcd0Hsz4nLTOgzkVuvfjiTYHTY3a6Oz3E2kqL1K7HVqdfnUSld0Y5xgSl2d/Gd9k//kH/odaIgplbmRzdHJlYW0KZW5kb2JqCjI5IDAgb2JqCjw8IC9MZW5ndGggMzk1IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD1SS27FQAjb5xRcoNLwm895UlXdvPtva0NSqSq8iTHGMH3KkLnlS10ScYXJt16uWzymfC5bWpl5iLuLjSU+ttyX7iG2XXQusTgdR/ILMp0qRKjNqtGh+EKWhQeQTvChC8J9Of7jL4DB17ANuOE9MkGwJOYpQsZuURmaEkERYeeRFaikUJ9Zwt9R7uv3MgVqb4ylC2Mc9Am0BUJtSMQC6kAAROyUVK2QjmckE78V3WdiHGDn0bIBrhlURJZ77MeIqc6ojLxExD5PTfoolkwtVsZuUxlf/JSM1Hx0BSqpNPKU8tBVs9ALWIl5EvY5/Ej459ZsIYY6btbyieUfM8UyEs5gSzlgoZfjR+DbWXURrh25uM50gR+V1nBMtOt+yPVP/nTbWs11vHIIokDlTUHwuw6uRrHExDI+nY0peqIssBqavEYzwWEQEdb3w8gDGv1yvBA0p2sitFgim7ViRI2KbHM9vQTWTO/FOdbDE8Js753WobIzMyohgtq6hmrrQHazvvNwtp8/M+iibQplbmRzdHJlYW0KZW5kb2JqCjMwIDAgb2JqCjw8IC9MZW5ndGggNzQgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicszC2UDBQMDQwUzA0N1IwNzZSMDE1UUgx5AIJgZi5XDDBHDDLGKgsByyLYEFkM8BsI1NTqB4QC6LHEK4SwYLIZnClAQBRvhkWCmVuZHN0cmVhbQplbmRvYmoKMzEgMCBvYmoKPDwgL0xlbmd0aCAxMzYgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTY9BDgMxCAPveYWfQCBAeM9WVQ/b/19L2HbTCx7JgGxRBoElh3iHG+HR2w/fRTYVZ+OcX1IpYiGYT3CfMFMcjSl38mOPgHGUaiynaHheS85NwxctdxMtpa2XkxlvuO6X90eVbZENRc8tC0LXbJL5MoEHfBiYR3XjaaXH3fZsr/b8AM5sNEkKZW5kc3RyZWFtCmVuZG9iagozMiAwIG9iago8PCAvTGVuZ3RoIDI0OSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxNUUmKAzAMu+cV+kAhXpO8p0OZQ+f/18oOhTkECa+Sk5aYWAsPMYQfLD34kSFzN/0bfqLZu1l6ksnZ/5jnIlNR+FKoLmJCXYgbz6ER8D2haxJZsb3xOSyjmXO+Bx+FuAQzoQFjfUkyuajmlSETTgx1HA5apMK4a2LD4lrRPI3cbvtGZmUmhA2PZELcGICIIOsCshgslDY2EzJZzgPtDckNWmDXqRtRi4IrlNYJdKJWxKrM4LPm1nY3Qy3y4Kh98fpoVpdghdFL9Vh4X4U+mKmZdu6SQnrhTTsizB4KpDI7LSu1e8TqboH6P8tS8P3J9/gdrw/N/FycCmVuZHN0cmVhbQplbmRvYmoKMzMgMCBvYmoKPDwgL0xlbmd0aCA5NCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxFjcERwCAIBP9UQQkKCtpPJpOH9v+NEDJ8YOcO7oQFC7Z5Rh8FlSZeFVgHSmPcUI9AveFyLcncBQ9wJ3/a0FScltN3aZFJVSncpBJ5/w5nJpCoedFjnfcLY/sjPAplbmRzdHJlYW0KZW5kb2JqCjM0IDAgb2JqCjw8IC9MZW5ndGggNzIgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicMzK3UDBQsDQBEoYWJgrmZgYKKYZcQL6piblCLhdIDMTKAbMMgLQlnIKIZ4CYIG0QxSAWRLGZiRlEHZwBkcvgSgMAJdsWyQplbmRzdHJlYW0KZW5kb2JqCjM1IDAgb2JqCjw8IC9MZW5ndGggNDcgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicMzK3UDBQsDQBEoYWJgrmZgYKKYZclhBWLhdMLAfMAtGWcAoinsGVBgC5Zw0nCmVuZHN0cmVhbQplbmRvYmoKMzYgMCBvYmoKPDwgL0xlbmd0aCAyNTggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicRZFLcgQgCET3noIjgPzkPJNKZTG5/zYNzmQ2dpeo/YRKI6YSLOcUeTB9yfLNZLbpdzlWOxsFFEUomMlV6LECqztTxJlriWrrY2XkuNM7BsUbzl05qWRxo4x1VHUqcEzPlfVR3fl2WZR9Rw5lCtiscxxs4MptwxgnRput7g73iSBPJ1NHxe0g2fAHJ419lasrcJ1s9tFLMA4E/UITmOSLQOsMgcbNU/TkEuzj43bngWBveRFI2RDIkSEYHYJ2nVz/4tb5vf9xhjvPtRmuHO/id5jWdsdfYpIVcwGL3Cmo52suWtcZOt6TM8fkpvuGzrlgl7uDTO/5P9bP+v4DHilm+gplbmRzdHJlYW0KZW5kb2JqCjM3IDAgb2JqCjw8IC9MZW5ndGggMTYzIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nEWQOxIDIQxDe06hI/gjAz7PZjIpNvdvY9hsUsDTWCCDuxOC1NqCieiCh7Yl3QXvrQRnY/zpNm41EuQEdYBWpONolFJ9ucVplXTxaDZzKwutEx1mDnqUoxmgEDoV3u2i5HKm7s75Q3D1X/W/Yt05m4mBycodCM3qU9z5NjuiurrJ/qTH3KzXfivsVWFpWUvLCbedu2ZACdxTOdqrPT8fCjr2CmVuZHN0cmVhbQplbmRvYmoKMzggMCBvYmoKPDwgL0xlbmd0aCAyMTggL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicPVC5jQQxDMtdhRpYwHrtqWcWi0um//RI+fYi0RZFUio1mZIpL3WUJVlT3jp8lsQOeYblbmQ2JSpFL5OwJffQCvF9ieYU993VlrNDNJdoOX4LMyqqGx3TSzaacCoTuqDcwzP6DW10A1aHHrFbINCkYNe2IHLHDxgMwZkTiyIMSk0G/65yj59eixs+w/FDFJGSDuY1/1j98nMNr1OPJ5Fub77iXpypDgMRHJKavCNdWLEuEhFpNUFNz8BaLYC7t17+G7QjugxA9onEcZpSjqG/a3Clzy/lJ1PYCmVuZHN0cmVhbQplbmRvYmoKMzkgMCBvYmoKPDwgL1R5cGUgL1hPYmplY3QgL1N1YnR5cGUgL0Zvcm0gL0JCb3ggWyAtMTAyMSAtNDYzIDE3OTQgMTIzMyBdCi9MZW5ndGggMTczIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDWQOw4DIQxEe07hC0TCfzjPSlGKzf3bjM2mYZ4YY3sYEpterPQdrNoUQatPyaBrANSFNpOZEpuQW+JedDXdg/9eLJRyq6SipohVSKZRQDJLrqGoBigGsO1WFYdhvpvupvJsS5W6r/M0dBZEZHcuPbOKanqgd23jO59NY+uzaT5eInSFKj0pi5A6J/cfOFKXYqNcTSYVjozPXBhT60Ld2v//4zU+4/0DmjI/5gplbmRzdHJlYW0KZW5kb2JqCjQwIDAgb2JqCjw8IC9MZW5ndGggODMgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicRYy7DcAwCER7pmAEfib2PlGUwt6/DRAlbrgn3T1cHQmZKW4zw0MGngwshl1xgfSWMAtcR1COneyjYdW+6gSN9aZS8+8PlJ7srOKG6wECQhpmCmVuZHN0cmVhbQplbmRvYmoKNDEgMCBvYmoKPDwgL0xlbmd0aCAyMzkgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTVDJbQQxDPu7CjUwwOgcux4Hizyy/X9DygmSl2hL4qHylFuWymX3IzlvybrlQ4dOlWnybtDNr7H+owwCdv9QVBCtJbFKzFzSbrE0SS/ZwziNl2u1juepe4RZo3jw49jTKYHpPTLBZrO9OTCrPc4OkE64xq/q0zuVJAOJupDzQqUK6x7UJaKPK9uYUp1OLeUYl5/oe3yOAD3F3o3c0cfLF4xGtS2o0WqVOA8wE1PRlXGrkYGUEwZDZ0dXNAulyMp6QjXCjTmhmb3DcGADy7OEpKWtUrwPZQHoAl3aOuM0SoKOAMLfKIz1+gaq/F43CmVuZHN0cmVhbQplbmRvYmoKNDIgMCBvYmoKPDwgL0xlbmd0aCAxNTAgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicPU85DsMwDNv9Cn4ggHVYtt6TIuiQ/n+t6KAdBBGgeMiyo2MFDjGBSccciZe0H/w0jUAsg5ojekLFMCxwNkmBh0FWSVc+W5xMIbUFXkj41hQ8G01kgp7HiB24k8noA+9SW7F16AHtEFUkXbMMY7GtunA9YQQ1xXoV5vUwY4mSR59VS+sBBRP40vl/7m7vdn0BYMUwXQplbmRzdHJlYW0KZW5kb2JqCjQzIDAgb2JqCjw8IC9MZW5ndGggMTUxIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDWPyw3DMAxD75qCCwTQz7I8T4qgh3T/ayWnBQyYMMkn2RaDkYxDTGDsmGPhJVRPrT4kI7e6STkQqVA3BE9oTAwznKRL4JXpvmU8t3g5rdQFnZDI3VltNEQZzTyGo6fsFU76L3OTqJUZZQ7IrFPdTsjKghWYF9Ry38+4rXKhEx62K8OiO8WIcpsZafj976Q3XV/ceDDVCmVuZHN0cmVhbQplbmRvYmoKNDQgMCBvYmoKPDwgL0xlbmd0aCA1MSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJwzNrRQMFAwNDAHkkaGQJaRiUKKIRdIAMTM5YIJ5oBZBkAaojgHriaHK4MrDQDhtA2YCmVuZHN0cmVhbQplbmRvYmoKNDUgMCBvYmoKPDwgL0xlbmd0aCAyNDMgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTVG7rQMxDOs9hRY4wPrZvnkueHjFZf82pJwEqURDFEnJw1O6ZMphfUpGSI4uD20aS2y6PDdCU4eKgqlrieqUq5mmzFMsTdDz3lmu5hjge1U31N/0iF4CkVGCVWGBDpA7uGD42WsmbFELIjGGUDOAacIKc7gSMQQZjLVnGJQqDE7VzypX+y+nZdgqsHgwnSI/sppop1+6HHjrKQdC2NyVu3ohTQjujQZjzCxcd6mynQAcTHSZiYxYvA3H0yEMDV6aBqxw1o2YILEbI6UPXgcZ07B3RR51txjxvlvGlLvVz31RfeZd7R8IwRsn+HsByhtdXgplbmRzdHJlYW0KZW5kb2JqCjQ2IDAgb2JqCjw8IC9MZW5ndGggMTYwIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nEWQORIDMQgEc72CJ0hcgvesy7XB+v+pB9ZHoukCNBy6Fk3KehRoPumxRqG60GvoLEqSRMEWkh1Qp2OIOyhITEhjkki2HoMjmlizXZiZVCqzUuG0acXCv9la1chEjXCN/InpBlT8T+pclPBNg6+SMfoYVLw7g4xJ+F5F3Fox7f5EMLEZ9glvRSYFhImxqdm+z2CGzPcK1zjH8w1MgjfrCmVuZHN0cmVhbQplbmRvYmoKNDcgMCBvYmoKPDwgL0xlbmd0aCAzMzQgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicLVJLcsUgDNtzCl2gM/gH5DzpdLp4vf+2kpNFRg5g9DHlholKfFkgt6PWxLeNzECF4a+rzIXPSNvIOojLkIu4ki2Fe0Qs5DHEPMSC76vxHh75rMzJswfGL9l3Dyv21IRlIePFGdphFcdhFeRYsHUhqnt4U6TDqSTY44v/PsVzLQQtfEbQgF/kn6+O4PmSFmn3mG3TrnqwTDuqpLAcbE9zXiZfWme5Oh7PB8n2rtgRUrsCFIW5M85z4SjTVka0FnY2SGpcbG+O/VhK0IVuXEaKI5CfqSI8oKTJzCYK4o+cHnIqA2Hqmq50chtVcaeezDWbi7czSWbrvkixmcJ5XTiz/gxTZrV5J89yotSpCO+xZ0vQ0Dmunr2WWWh0mxO8pITPxk5PTr5XM+shORUJqWJaV8FpFJliCdsSX1NRU5p6Gf778u7xO37+ASxzfHMKZW5kc3RyZWFtCmVuZG9iago0OCAwIG9iago8PCAvTGVuZ3RoIDMyMCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw1UktuBTEI288puECl8E/O86qqi777b2sTvRVMMGDjKS9Z0ku+1CXbpcPkWx/3JbFC3o/tmsxSxfcWsxTPLa9HzxG3LQoEURM9WJkvFSLUz/ToOqhwSp+BVwi3FBu8g0kAg2r4Bx6lMyBQ50DGu2IyUgOCJNhzaXEIiXImiX+kvJ7fJ62kofQ9WZnL35NLpdAdTU7oAcXKxUmgXUn5oJmYSkSSl+t9sUL0hsCSPD5HMcmA7DaJbaIFJucepSXMxBQ6sMcCvGaa1VXoYMIehymMVwuzqB5s8lsTlaQdreMZ2TDeyzBTYqHhsAXU5mJlgu7l4zWvwojtUZNdw3Duls13CNFo/hsWyuBjFZKAR6exEg1pOMCIwJ5eOMVe8xM5DsCIY52aLAxjaCaneo6JwNCes6VhxsceWvXzD1TpfIcKZW5kc3RyZWFtCmVuZG9iago0OSAwIG9iago8PCAvTGVuZ3RoIDU0IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDM2NlcwAEJdSyMFYyDb3MhSIcWQy8jUBMzM5YIJ5nBZGINV5XAZQGmYohyuDK40APuEDh8KZW5kc3RyZWFtCmVuZG9iago1MCAwIG9iago8PCAvTGVuZ3RoIDE4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDM2tFAwgMMUQ640AB3mA1IKZW5kc3RyZWFtCmVuZG9iago1MSAwIG9iago8PCAvTGVuZ3RoIDEzMyAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxFj0sOBCEIRPecoo7Axx/ncTLphXP/7YCdbhNjPYVUgbmCoT0uawOdFR8hGbbxt6mWjkVZPlR6UlYPyeCHrMbLIdygLPCCSSqGIVCLmBqRLWVut4DbNg2yspVTpY6wi6Mwj/a0bBUeX6JbInWSP4PEKi/c47odyKXWu96ii75/pAExCQplbmRzdHJlYW0KZW5kb2JqCjUyIDAgb2JqCjw8IC9MZW5ndGggMjUxIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nC1RSXIDQQi7zyv0hGan32OXK4fk/9cIygcGDYtAdFrioIyfICxXvOWRq2jD3zMxgt8Fh34r121Y5EBUIEljUDWhdvF69B7YcZgJzJPWsAxmrA/8jCnc6MXhMRlnt9dl1BDsXa89mUHJrFzEJRMXTNVhI2cOP5kyLrRzPTcg50ZYl2GQblYaMxKONIVIIYWqm6TOBEESjK5GjTZyFPulL490hlWNqDHscy1tX89NOGvQ7Fis8uSUHl1xLicXL6wc9PU2AxdRaazyQEjA/W4P9XOyk994S+fOFtPje83J8sJUYMWb125ANtXi37yI4/uMr+fn+fwDX2BbiAplbmRzdHJlYW0KZW5kb2JqCjUzIDAgb2JqCjw8IC9MZW5ndGggMTc0IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nE2QSQ5DIQxD95zCF6iEM8DnPL+qumjvv61DB3WB/OQgcDw80HEkLnRk6IyOK5sc48CzIGPi0Tj/ybg+xDFB3aItWJd2x9nMEnPCMjECtkbJ2TyiwA/HXAgSZJcfvsAgIl2P+VbzWZP0z7c73Y+6tGZfPaLAiewIxbABV4D9useBS8L5XtPklyolYxOH8oHqIlI2O6EQtVTscqqKs92bK3AV9PzRQ+7tBbUjPN8KZW5kc3RyZWFtCmVuZG9iago1NCAwIG9iago8PCAvTGVuZ3RoIDU0IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDM1MFAwUNC1VNA1MjZVMDUEsg3NTBVSDLng7FwIEySfwwVTCWGBpHMQKnO4MrjSAHNRD48KZW5kc3RyZWFtCmVuZG9iago1NSAwIG9iago8PCAvTGVuZ3RoIDc1IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDO1NFIwUDA2ABKmZkYKpibmCimGXEA+iJXLZWhkCmblcBlZmilYWAAZJmbmUCGYhhwuY1NzoAFARcamYBqqP4crgysNAJWQEu8KZW5kc3RyZWFtCmVuZG9iago1NiAwIG9iago8PCAvTGVuZ3RoIDE0MSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw9j8EOwzAIQ+/5Cv9ApNgpoXxPp2qH7v+vI0u7C3oCY4yF0NAbqprDhmCb48XSJVRr+BTFQCU3yJlgDqWk0h1HkXpiOBhcHrQbjuKx6PoRu5JmfdDGQrolaIB7rFNp3KZxE8QdNQXqKeqco7wQuZ+pZ9g0kt00s5JzuA2/e89T1/+nq7zL+QW9dy7+CmVuZHN0cmVhbQplbmRvYmoKNTcgMCBvYmoKPDwgL0xlbmd0aCA3NiAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw9jDsOgDAMQ/ecwkdofiQHQoiB3n+lKbSL/fQk28XRYFqRArfAyeQ+qdNyzyQ7fBCbIeRXG1q1rsrSmgyLmoy/Dd/dTdcLpjgXwAplbmRzdHJlYW0KZW5kb2JqCjU4IDAgb2JqCjw8IC9MZW5ndGggMjE1IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDVROQ4DIQzs9xX+QCSML3hPoijN/r/NjNFWHsFchrSUIZnyUpOoIeVTPnqZLpy63NfMajTnlrQtc4C4trwvrZLAiWaIg8FpmLgBmjwBQ9fRqFFDFx7Q1KVTKLDcBD6Kt24P3WO1gZe2IeeJIGIoGSxBzalFExZtzyekNb9eixvel+3dyFOlxpYYgQYBVjgc1+jX8JU9TybRdBUy1Ks1yxgJE0UiPPmOptUT61o00jIS1MYRrGoDvDv9ME4AABNxywJkn0qUs+TEb7H0swZX+v4Bn0dUlgplbmRzdHJlYW0KZW5kb2JqCjE1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9CYXNlRm9udCAvQk1RUURWK0RlamFWdVNhbnMgL0ZpcnN0Q2hhciAwIC9MYXN0Q2hhciAyNTUKL0ZvbnREZXNjcmlwdG9yIDE0IDAgUiAvU3VidHlwZSAvVHlwZTMgL05hbWUgL0JNUVFEVitEZWphVnVTYW5zCi9Gb250QkJveCBbIC0xMDIxIC00NjMgMTc5NCAxMjMzIF0gL0ZvbnRNYXRyaXggWyAwLjAwMSAwIDAgMC4wMDEgMCAwIF0KL0NoYXJQcm9jcyAxNiAwIFIKL0VuY29kaW5nIDw8IC9UeXBlIC9FbmNvZGluZwovRGlmZmVyZW5jZXMgWyAzMiAvc3BhY2UgNDAgL3BhcmVubGVmdCAvcGFyZW5yaWdodCA0NiAvcGVyaW9kIC9zbGFzaCAvemVybyAvb25lIC90d28gNTIKL2ZvdXIgL2ZpdmUgL3NpeCA1NiAvZWlnaHQgNjEgL2VxdWFsIDY3IC9DIDY5IC9FIC9GIC9HIC9IIDc0IC9KIDgwIC9QIDgzIC9TCjk1IC91bmRlcnNjb3JlIDk3IC9hIDk5IC9jIC9kIC9lIC9mIDEwNSAvaSAxMDggL2wgL20gL24gL28gL3AgL3EgL3IgL3MgL3QKL3UgL3YgMTIxIC95IC96IF0KPj4KL1dpZHRocyAxMyAwIFIgPj4KZW5kb2JqCjE0IDAgb2JqCjw8IC9UeXBlIC9Gb250RGVzY3JpcHRvciAvRm9udE5hbWUgL0JNUVFEVitEZWphVnVTYW5zIC9GbGFncyAzMgovRm9udEJCb3ggWyAtMTAyMSAtNDYzIDE3OTQgMTIzMyBdIC9Bc2NlbnQgOTI5IC9EZXNjZW50IC0yMzYgL0NhcEhlaWdodCAwCi9YSGVpZ2h0IDAgL0l0YWxpY0FuZ2xlIDAgL1N0ZW1WIDAgL01heFdpZHRoIDEzNDIgPj4KZW5kb2JqCjEzIDAgb2JqClsgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAKNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCAzMTggNDAxIDQ2MCA4MzggNjM2Cjk1MCA3ODAgMjc1IDM5MCAzOTAgNTAwIDgzOCAzMTggMzYxIDMxOCAzMzcgNjM2IDYzNiA2MzYgNjM2IDYzNiA2MzYgNjM2IDYzNgo2MzYgNjM2IDMzNyAzMzcgODM4IDgzOCA4MzggNTMxIDEwMDAgNjg0IDY4NiA2OTggNzcwIDYzMiA1NzUgNzc1IDc1MiAyOTUKMjk1IDY1NiA1NTcgODYzIDc0OCA3ODcgNjAzIDc4NyA2OTUgNjM1IDYxMSA3MzIgNjg0IDk4OSA2ODUgNjExIDY4NSAzOTAgMzM3CjM5MCA4MzggNTAwIDUwMCA2MTMgNjM1IDU1MCA2MzUgNjE1IDM1MiA2MzUgNjM0IDI3OCAyNzggNTc5IDI3OCA5NzQgNjM0IDYxMgo2MzUgNjM1IDQxMSA1MjEgMzkyIDYzNCA1OTIgODE4IDU5MiA1OTIgNTI1IDYzNiAzMzcgNjM2IDgzOCA2MDAgNjM2IDYwMCAzMTgKMzUyIDUxOCAxMDAwIDUwMCA1MDAgNTAwIDEzNDIgNjM1IDQwMCAxMDcwIDYwMCA2ODUgNjAwIDYwMCAzMTggMzE4IDUxOCA1MTgKNTkwIDUwMCAxMDAwIDUwMCAxMDAwIDUyMSA0MDAgMTAyMyA2MDAgNTI1IDYxMSAzMTggNDAxIDYzNiA2MzYgNjM2IDYzNiAzMzcKNTAwIDUwMCAxMDAwIDQ3MSA2MTIgODM4IDM2MSAxMDAwIDUwMCA1MDAgODM4IDQwMSA0MDEgNTAwIDYzNiA2MzYgMzE4IDUwMAo0MDEgNDcxIDYxMiA5NjkgOTY5IDk2OSA1MzEgNjg0IDY4NCA2ODQgNjg0IDY4NCA2ODQgOTc0IDY5OCA2MzIgNjMyIDYzMiA2MzIKMjk1IDI5NSAyOTUgMjk1IDc3NSA3NDggNzg3IDc4NyA3ODcgNzg3IDc4NyA4MzggNzg3IDczMiA3MzIgNzMyIDczMiA2MTEgNjA1CjYzMCA2MTMgNjEzIDYxMyA2MTMgNjEzIDYxMyA5ODIgNTUwIDYxNSA2MTUgNjE1IDYxNSAyNzggMjc4IDI3OCAyNzggNjEyIDYzNAo2MTIgNjEyIDYxMiA2MTIgNjEyIDgzOCA2MTIgNjM0IDYzNCA2MzQgNjM0IDU5MiA2MzUgNTkyIF0KZW5kb2JqCjE2IDAgb2JqCjw8IC9DIDE3IDAgUiAvRSAxOCAwIFIgL0YgMTkgMCBSIC9HIDIwIDAgUiAvSCAyMSAwIFIgL0ogMjIgMCBSIC9QIDIzIDAgUgovUyAyNCAwIFIgL2EgMjUgMCBSIC9jIDI2IDAgUiAvZCAyNyAwIFIgL2UgMjggMCBSIC9laWdodCAyOSAwIFIKL2VxdWFsIDMwIDAgUiAvZiAzMSAwIFIgL2ZpdmUgMzIgMCBSIC9mb3VyIDMzIDAgUiAvaSAzNCAwIFIgL2wgMzUgMCBSCi9tIDM2IDAgUiAvbiAzNyAwIFIgL28gMzggMCBSIC9vbmUgNDAgMCBSIC9wIDQxIDAgUiAvcGFyZW5sZWZ0IDQyIDAgUgovcGFyZW5yaWdodCA0MyAwIFIgL3BlcmlvZCA0NCAwIFIgL3EgNDUgMCBSIC9yIDQ2IDAgUiAvcyA0NyAwIFIgL3NpeCA0OCAwIFIKL3NsYXNoIDQ5IDAgUiAvc3BhY2UgNTAgMCBSIC90IDUxIDAgUiAvdHdvIDUyIDAgUiAvdSA1MyAwIFIKL3VuZGVyc2NvcmUgNTQgMCBSIC92IDU1IDAgUiAveSA1NiAwIFIgL3ogNTcgMCBSIC96ZXJvIDU4IDAgUiA+PgplbmRvYmoKMyAwIG9iago8PCAvRjEgMTUgMCBSID4+CmVuZG9iago0IDAgb2JqCjw8IC9BMSA8PCAvVHlwZSAvRXh0R1N0YXRlIC9DQSAwIC9jYSAxID4+Ci9BMiA8PCAvVHlwZSAvRXh0R1N0YXRlIC9DQSAxIC9jYSAxID4+Ci9BMyA8PCAvVHlwZSAvRXh0R1N0YXRlIC9DQSAwLjggL2NhIDAuOCA+PiA+PgplbmRvYmoKNSAwIG9iago8PCA+PgplbmRvYmoKNiAwIG9iago8PCA+PgplbmRvYmoKNyAwIG9iago8PCAvRjEtRGVqYVZ1U2Fucy1vbWVnYSAzOSAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFsgMTEgMCBSIF0gL0NvdW50IDEgPj4KZW5kb2JqCjU5IDAgb2JqCjw8IC9DcmVhdG9yIChNYXRwbG90bGliIHYzLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcpCi9Qcm9kdWNlciAoTWF0cGxvdGxpYiBwZGYgYmFja2VuZCB2My4xMC4xKQovQ3JlYXRpb25EYXRlIChEOjIwMjUwNjA5MDgxMTA0KzA2JzAwJykgPj4KZW5kb2JqCnhyZWYKMCA2MAowMDAwMDAwMDAwIDY1NTM1IGYgCjAwMDAwMDAwMTYgMDAwMDAgbiAKMDAwMDAxNjMzOSAwMDAwMCBuIAowMDAwMDE2MDc0IDAwMDAwIG4gCjAwMDAwMTYxMDYgMDAwMDAgbiAKMDAwMDAxNjI0OCAwMDAwMCBuIAowMDAwMDE2MjY5IDAwMDAwIG4gCjAwMDAwMTYyOTAgMDAwMDAgbiAKMDAwMDAwMDA2NSAwMDAwMCBuIAowMDAwMDAwMzQwIDAwMDAwIG4gCjAwMDAwMDM0NzcgMDAwMDAgbiAKMDAwMDAwMDIwOCAwMDAwMCBuIAowMDAwMDAzNDU2IDAwMDAwIG4gCjAwMDAwMTQ1MjcgMDAwMDAgbiAKMDAwMDAxNDMyMCAwMDAwMCBuIAowMDAwMDEzNzc0IDAwMDAwIG4gCjAwMDAwMTU1ODAgMDAwMDAgbiAKMDAwMDAwMzQ5NyAwMDAwMCBuIAowMDAwMDAzODA1IDAwMDAwIG4gCjAwMDAwMDM5NTggMDAwMDAgbiAKMDAwMDAwNDEwNiAwMDAwMCBuIAowMDAwMDA0NDI2IDAwMDAwIG4gCjAwMDAwMDQ1NzcgMDAwMDAgbiAKMDAwMDAwNDc2NSAwMDAwMCBuIAowMDAwMDA1MDA4IDAwMDAwIG4gCjAwMDAwMDU0MjIgMDAwMDAgbiAKMDAwMDAwNTgwMiAwMDAwMCBuIAowMDAwMDA2MTA3IDAwMDAwIG4gCjAwMDAwMDY0MTEgMDAwMDAgbiAKMDAwMDAwNjczMyAwMDAwMCBuIAowMDAwMDA3MjAxIDAwMDAwIG4gCjAwMDAwMDczNDcgMDAwMDAgbiAKMDAwMDAwNzU1NiAwMDAwMCBuIAowMDAwMDA3ODc4IDAwMDAwIG4gCjAwMDAwMDgwNDQgMDAwMDAgbiAKMDAwMDAwODE4OCAwMDAwMCBuIAowMDAwMDA4MzA3IDAwMDAwIG4gCjAwMDAwMDg2MzggMDAwMDAgbiAKMDAwMDAwODg3NCAwMDAwMCBuIAowMDAwMDA5MTY1IDAwMDAwIG4gCjAwMDAwMDk0NzIgMDAwMDAgbiAKMDAwMDAwOTYyNyAwMDAwMCBuIAowMDAwMDA5OTM5IDAwMDAwIG4gCjAwMDAwMTAxNjIgMDAwMDAgbiAKMDAwMDAxMDM4NiAwMDAwMCBuIAowMDAwMDEwNTA5IDAwMDAwIG4gCjAwMDAwMTA4MjUgMDAwMDAgbiAKMDAwMDAxMTA1OCAwMDAwMCBuIAowMDAwMDExNDY1IDAwMDAwIG4gCjAwMDAwMTE4NTggMDAwMDAgbiAKMDAwMDAxMTk4NCAwMDAwMCBuIAowMDAwMDEyMDc0IDAwMDAwIG4gCjAwMDAwMTIyODAgMDAwMDAgbiAKMDAwMDAxMjYwNCAwMDAwMCBuIAowMDAwMDEyODUxIDAwMDAwIG4gCjAwMDAwMTI5NzcgMDAwMDAgbiAKMDAwMDAxMzEyNCAwMDAwMCBuIAowMDAwMDEzMzM4IDAwMDAwIG4gCjAwMDAwMTM0ODYgMDAwMDAgbiAKMDAwMDAxNjM5OSAwMDAwMCBuIAp0cmFpbGVyCjw8IC9TaXplIDYwIC9Sb290IDEgMCBSIC9JbmZvIDU5IDAgUiA+PgpzdGFydHhyZWYKMTY1NTgKJSVFT0YK", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2025-06-09T08:11:04.575088\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.10.1, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" + "cell_type": "code", + "execution_count": 2, + "id": "5a414d20", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5a414d20", + "outputId": "2e74fb53-f759-467f-e40e-240df6f5ad2e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Energy levels: [-45.06331229 -35.3200142 -25.84262677 -16.64359749 -7.737526\n", + " 0.85814084]\n" + ] + } ], - "text/plain": [ - "
" + "source": [ + "import scqubits as scq\n", + "\n", + "# Define a Transmon qubit with specific numerical parameters\n", + "transmon = scq.Transmon(\n", + " EJ=50.0, # Josephson energy in GHz\n", + " EC=0.25, # Charging energy in GHz\n", + " ng=0.0, # Gate charge\n", + " ncut=30 # Truncation parameter for the Hilbert space\n", + ")\n", + "\n", + "# Calculate the energy levels (eigenvalues) of the qubit\n", + "evals = transmon.eigenvals()\n", + "\n", + "print(\"Energy levels:\", evals)" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Fix EC to a numerical value, say 0.25 GHz\n", - "EC_fixed = 0.25\n", - "\n", - "# Create numerical functions for sensitivities\n", - "sensitivity_EJ_func = sp.lambdify(EJ, sensitivity_EJ.subs(EC, EC_fixed), 'numpy')\n", - "sensitivity_EC_func = sp.lambdify(EJ, sensitivity_EC.subs(EC, EC_fixed), 'numpy')\n", - "\n", - "# Define a range for EJ\n", - "EJ_range = np.linspace(10, 100, 100)\n", - "\n", - "# Compute sensitivities\n", - "sensitivity_EJ_values = sensitivity_EJ_func(EJ_range)\n", - "sensitivity_EC_values = sensitivity_EC_func(EJ_range)\n", - "\n", - "# Plot\n", - "plt.figure(figsize=(10, 6))\n", - "plt.plot(EJ_range, sensitivity_EJ_values, label='dω_p / dE_J', color='blue')\n", - "plt.plot(EJ_range, sensitivity_EC_values, label='dω_p / dE_C', color='orange')\n", - "plt.xlabel('E_J (GHz)')\n", - "plt.ylabel('Sensitivity')\n", - "plt.title('Sensitivities of Plasma Frequency to E_J and E_C (E_C = 0.25 GHz)')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5379a173", - "metadata": {}, - "source": [ - "From this plot, we can see that:\n", - "- The sensitivity to \\(E_J\\) decreases as \\(E_J\\) increases, meaning larger \\(E_J\\) values make \\(\\omega_p\\) less sensitive to changes in \\(E_J\\).\n", - "- The sensitivity to \\(E_C\\) remains relatively constant, indicating that changes in \\(E_C\\) have a consistent impact on \\(\\omega_p\\).\n", - "\n", - "This visualization provides deeper insight into how to tune qubit parameters for desired behavior.\n", - "\n", - "## Combining scqubits and sympy: The Best of Both Worlds\n", - "\n", - "Now, let’s bring scqubits and sympy together to analyze quantum circuits in a powerful way. The catch is that scqubits expects numerical values for parameters like \\(E_J\\) and \\(E_C\\), so we can’t directly use symbols in scqubits calculations. But we can use sympy to derive general relationships and then plug in numbers to connect back to scqubits.\n", - "\n", - "Let’s try defining a Transmon qubit with symbolic parameters to see what happens:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "da8bb5df", - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error: object arrays are not supported\n" - ] - } - ], - "source": [ - "# Try to define a Transmon with symbolic parameters\n", - "try:\n", - " transmon_sym = scq.Transmon(EJ=EJ, EC=EC, ng=0.0, ncut=30)\n", - " evals_sym = transmon_sym.eigenvals()\n", - "except Exception as e:\n", - " print(\"Error:\", e)" - ] - }, - { - "cell_type": "markdown", - "id": "caf08890", - "metadata": {}, - "source": [ - "\n", - "As expected, this doesn’t work because scqubits needs numbers, not symbols, to compute things like eigenvalues. So, instead, we’ll use sympy to work with our symbolic expressions and then substitute numerical values when we need to connect to scqubits or create visualizations.\n", - "\n", - "### Example: Solving for \\(E_J\\)\n", - "\n", - "Suppose we want to design a qubit with a plasma frequency of 5 GHz, and we know \\(E_C = 0.25\\) GHz. We can use our symbolic expression for \\(\\omega_p\\) to find the required \\(E_J\\):" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ad90a6ff", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "a9d7fe1d", + "metadata": { + "id": "a9d7fe1d" + }, + "source": [ + "This code sets up a Transmon qubit with \\(E_J = 50\\) GHz and \\(E_C = 0.25\\) GHz, then computes its energy levels. These levels tell us the possible energy states the qubit can have, which is key for understanding how it behaves in a quantum circuit.\n", + "\n", + "One thing to note: scqubits is great for numerical calculations, but it doesn’t handle symbolic parameters (like variables instead of numbers). That’s where sympy comes in, and we’ll explore that next!" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Required E_J for ω_p = 5 GHz: [12.5000000000000]\n" - ] - } - ], - "source": [ - "# Set the desired plasma frequency\n", - "desired_omega_p = 5.0 # in GHz\n", - "\n", - "# Set a numerical value for EC\n", - "EC_num = 0.25 # in GHz\n", - "\n", - "# Substitute EC into the plasma frequency expression\n", - "omega_p_with_EC = omega_p.subs(EC, EC_num)\n", - "\n", - "# Solve for EJ to achieve the desired omega_p\n", - "solution = sp.solve(omega_p_with_EC - desired_omega_p, EJ)\n", - "\n", - "print(\"Required E_J for ω_p = 5 GHz:\", solution)" - ] - }, - { - "cell_type": "markdown", - "id": "77b51c55", - "metadata": {}, - "source": [ - "This code uses sympy to solve the equation \\(\\sqrt{8 E_J \\cdot 0.25} = 5\\), giving us the value of \\(E_J\\) needed for the desired frequency. Isn’t that cool? We’re using math to design our qubit!\n", - "\n", - "### Visualizing the Relationship\n", - "\n", - "To get a better sense of how \\(\\omega_p\\) depends on \\(E_J\\), let’s create a plot. We’ll use sympy to turn our symbolic expression into a numerical function and then use matplotlib to visualize it:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6b76a985", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "c40c9981", + "metadata": { + "id": "c40c9981" + }, + "source": [ + "## Getting Started with sympy: Your Math Wizard\n", + "\n", + "While scqubits is awesome for crunching numbers, sometimes we want to work with general formulas instead of specific values. That’s where `sympy` shines. Sympy lets you define variables as symbols and perform algebraic operations, like solving equations, taking derivatives, or simplifying expressions.\n", + "\n", + "Let’s try it out by defining the Josephson energy (\\(E_J\\)) and charging energy (\\(E_C\\)) as symbols:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6ff51ea9", + "metadata": { + "id": "6ff51ea9" + }, + "outputs": [], + "source": [ + "import sympy as sp\n", + "\n", + "# Define symbolic variables for Josephson and charging energies\n", + "EJ, EC = sp.symbols('E_J E_C')" + ] + }, + { + "cell_type": "markdown", + "id": "a8d24bc4", + "metadata": { + "id": "a8d24bc4" + }, + "source": [ + "Now, let’s use these symbols to define an important property of the Transmon qubit: the **plasma frequency** (\\(\\omega_p\\)). This is like the natural “vibration” frequency of the qubit, and it’s approximately given by the formula:\n", + "\n", + "\\[\n", + "\\omega_p = \\sqrt{8 E_J E_C}\n", + "\\]\n", + "\n", + "Here’s how we can define it in sympy:" + ] + }, { - "data": { - "application/pdf": "JVBERi0xLjQKJazcIKu6CjEgMCBvYmoKPDwgL1R5cGUgL0NhdGFsb2cgL1BhZ2VzIDIgMCBSID4+CmVuZG9iago4IDAgb2JqCjw8IC9Gb250IDMgMCBSIC9YT2JqZWN0IDcgMCBSIC9FeHRHU3RhdGUgNCAwIFIgL1BhdHRlcm4gNSAwIFIKL1NoYWRpbmcgNiAwIFIgL1Byb2NTZXQgWyAvUERGIC9UZXh0IC9JbWFnZUIgL0ltYWdlQyAvSW1hZ2VJIF0gPj4KZW5kb2JqCjExIDAgb2JqCjw8IC9UeXBlIC9QYWdlIC9QYXJlbnQgMiAwIFIgL1Jlc291cmNlcyA4IDAgUgovTWVkaWFCb3ggWyAwIDAgNDA1LjE5MTg3NSAzMjYuMjYyIF0gL0NvbnRlbnRzIDkgMCBSIC9Bbm5vdHMgMTAgMCBSID4+CmVuZG9iago5IDAgb2JqCjw8IC9MZW5ndGggMTIgMCBSIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nMWYT3NVRw7F9/dT9BIWtLtbre7WYhYhEKZYDYHKLCZTlMtxnFDYBFxJKvPp56e+5v2x8cOuVAEuw3uHe3WlI+lIfY+enP7x68np988eh29fLkfbbyeXSw5v+D0LKbzh98+QwzN+z5bEt/OlJo3Z8ujK17e7X6W0WFoBTDuff1mWn5ejbzBwyQ3PFu6Io6839DiKYlOsR7Nd7O0eliSa9Pm0zb0bbD7gfbhhVrTHXEJpLWb+/XAa/h0uwtE3xT0p4TkxEV8cRJhis5StpT7q8izs02ESc+8iW3e3yMaJ5eXyIrz/aD3B3o51+AM5aKhGmVEvj6H+z+U9f6fwKGFltDhyN638aCgSi2QuPTlfHr9ajr7LIafw6ueZnFc/Lf8JD0p6GP4bXj1fnr5aXkyv/gY1yy414To1uSl+F/+vTUy72L3o+Zyx2ynKOqI1qcn85y4c1S/HUcFebaOIbcPaxe7F0eeM3c4RjMScxmjCT70LR+3LcSTJYsvSbKc3drF7cfQ5Y7dz5M8pWiUP/7kLR+MLcjRy7Gq5jp2wdrD7cfQZYwc46iWWktJQ2lLuwlFOeyTt9q21qNXvtqiK94fMPH39PPz44Nk///fjwy/G+Y7hQfeYpHxtWm3gu/F+i8Ee5Tr6yR7uUZ0tT08utaji+SGV+wpEDSKotTbZJ2oL35eoPYMbovbs3UrUgKjalRuStkNS9xWIyp7rbu36ArSD35eqfZMbrvYt3kpW9rIapVfTZOWQ6H0Ntkh4ybWPfo2tLX5vtvZMbtnas3iTLcaoTsXLVFeF15yhbxwUwK9AWCHppZpV2ydsB78vYfsmN4TtWzxAWKHAqkrqopkV5ABh5WsQ5nkfmvM1id/B703YnsktYXsWDxHmFTbY7FQLI+EAYXV/wrqZR24w19jnXM1VOY8x4j8xqgeO1UR2ZJ7pVpOvf7s5bd8TaXKzafvh5Dxg6dGT0zfHP/z+8vji8tG789Oz4/DkXXjxt5KXozqppE8/Zk943vfXM7i4sVRbKqFatOJct4SSidUctMZhrBZem01ia0KrKstg62wcDrZotTTmaKssf8OKH1p7YsnJpiO0EduwJBMV96VYCyxB1qX36miLfaQmGrqH1XT4tQOG1Iwrhudz8BBHJYqYZAlDYxqpzwHGEa/l0bT4WLOUWmuOGq53qjBYiY3DdHJF2hwZzQ/YnL7dLJ+rctcIxk3USnap53OXlrgt+2Jr1voA9i+JCqsNHN9Tr10mjkXjJEG1ZLyvvbf1erYzL5AKjv+lzlDIXBwqHCeAfY9jb9GJk1UpnfrIGQ9S0um4f2HXS1gp3Jla0gnzpVmWbuAaB3mc0fsXwzf2cNQVnHSt1xtpSn5z5kgzSpUyr5cStZDoNgdZl6E63RGMpoHmgHd4ptBntGIkgAzgPgVaa84rC7VEaR1PwX25lTTrxBuoVaomz16y0Wub9ispK41jp3/qSUfzts7Kmpy0FnDNVCPjt05caenqzGZqM9WU6opzc6vkAJxy0CErm61wkdSK+5RtIc0yw90ejHODhiRpte/1mkouhEVBi/D06U/nopFrIyxKfki5or9rzI1KJKxmkWB1TXofcJJgKfitHWrnUpr9kJCN8QheKcU6+qwGpMqMJ5AWGkJ7KbriaF0fxBTcpFWlqhw3+lt91whukp7Ka1UZDSttCHHRLJCWZi1nY4chUk8XrcOKnIr7Sa1HMfUg9wY3dRbJoteykd3OwXeF0XWOHIOw6Cq8HMXDKjl7qhWb7gHx0WQTr74c+c2ZkUBWq8zH5o6wcg4iLNqMnqaWHEe8qVklp+4Zlc+BauLkQrmGExPt5+m9wilJUofokBBMwounsUhCCEyppekyx60+r6e0idMYEnQoZT1rfOcNAJmPbG+jTpzCprmhPHgg0OcOO07lFbqugTcnLa/eV2ZUYk9k9GTI1JJXkhURpp+MqArK2FV0eqlCY1ajoYiAmYadCXdfzguF4XGTfpsKQJfEWqSRq+KvB9WGTFjom+L7A+lAdzsnyokjzQPIT+KJsNljvUSKi3OjMYiKpkdAdK4exeUZFUI+nCZkx9ZSoB7RREobnNJpbdXi4hKNKHqufDD11FY2XaTxmYfBKF3JXZO1sfYlBVNqRgzwdPqJUDNj/bEIhtLCeV6OUsOuGWEhGGhKS5M0F2trQh053wW1WkvK5bpr82QxyFIdkt19P9gnP+nhvvok5Snz/ShyLdxLJkgUQwp9XK/fvOqAGMTGcpm46zV9wyQrKAyFP2tBXK5hnFCYfjGRzjomjlxrnjAzBX2eMojmoK3MW6JCdxrjcJaCv+9NTBYY93zilVmZOKLFGEOjmYzO9yrX4nLNXoaGlqlHiM2KI9cIJFQVpExb8snguJFpBi5Ref4ZgWM+F7muqSdPFjplVOl86ywu19Smw+LkMM4m7G8Kla4EJyl9HSrial29YIA7dNM/86moNS3PYgSOQOP7fChEobiuZF5EYqPNmSIu1qTNUzX4qG3dMcTFGinzVA0v9qZX1yPWfoTAS0QN59oUX/FIkCTawIuONklTNHGXoeKR+ArJzBmrO67V3Ya/+jRfXHycOr59oQMErTc3WF+2ttvrrS8/Pr4i+tTrdwzefH1//unX91x7x7f/+1deGbjdavI4rrbxPKM5212p6bPkr/dmo+7uv2Vnj/at919vjy/Pj8N3DwMpYCT5GOZPePDhIUIc128rcvr+99OLk7/CH5fh+bvL099+uXx3EZ5enH54yBAmfdTk1ZVnf7FKP339bfgHXBPdx6162Zxwlv8Dys9BRAplbmRzdHJlYW0KZW5kb2JqCjEyIDAgb2JqCjIwOTYKZW5kb2JqCjEwIDAgb2JqClsgXQplbmRvYmoKMTcgMCBvYmoKPDwgL0xlbmd0aCAyMzUgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicNVFJbgAxCLvnFf5ApbAn75mq6qH9/7WGUS8DA9jYJO/BRiQ+xJDuKFd8yuo0y/A7WeTFz0rh5L2ICqQqwgppB89yVjMMnhuZApcz8VlmPpkWOxZQTcRxduQ0g0GIaVxHy+kw0zzoCbk+GHFjp1muYkjr3VK9vtfynyrKR9bdLLdO2dRK3aJn7Elcdl5PbWlfGHUUNwWRDh87vAf5IuYsLjqRbvabKYeVpCE4LYAfiaFUzw6vESZ+ZiR4yp5O76M0vPZB0/W9e0FHbiZkKrdQRiqerDTGjKH6jWgmqe//gZ71vb7+AENNVLkKZW5kc3RyZWFtCmVuZG9iagoxOCAwIG9iago8PCAvTGVuZ3RoIDgxIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nE3Nuw3AIAwE0J4pPALg/z5RlCLZv40NEaGxn3QnnWCHCm5xWAy0Oxyt+NRTmH3oHhKSUHPdRFgzJdqEpF/6yzDDmFjItq83V65yvhbcHIsKZW5kc3RyZWFtCmVuZG9iagoxOSAwIG9iago8PCAvTGVuZ3RoIDc2IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDM1N1UwULC0ABKmhuYK5kaWCimGXEA+iJXLBRPLAbPMTMyALENLZJaJsSGQZWJhhsQyNrGAyiJYBkAabE0OzPQcrgyuNAA1FxkFCmVuZHN0cmVhbQplbmRvYmoKMjAgMCBvYmoKPDwgL0xlbmd0aCAyNDcgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTVFJbsQwDLv7FfzAAJasxXlPikEP7f+vJR0U7cEQI0tc4u7ERBZetlDXQofjw0ZeCZuB74PWnPgaseI/2kaklT9UWyATMVEkdFE3GvdIN7wK0X6kgleq91jzEXcrzVs6drG/98G05pEqq0I85Ngc2Uha10TR8T203nNDdMoggT43IQdEaY5ehaS/9sN1bTS7tTazJ6qDR6aE8kmzGprTKWbIbKjHbSpWMgo3qoyK+1RGWg/yNs4ygJPjhDJaT3asJqL81CeXkBcTccIuOzsWYhMLG4e0H5U+sfx86834m2mtpZBxQSI0xaXfZ7zH53j/AJVPXCYKZW5kc3RyZWFtCmVuZG9iagoyMSAwIG9iago8PCAvTGVuZ3RoIDc5IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDM3NVIwULC0ABJmpiYK5kaWCimGXEA+iJXLZWhpDmblgFkmxgZAlqmpKRILIgvTC2HB5GC0sYk51AQECyQHtjYHZlsOVwZXGgDWlBwMCmVuZHN0cmVhbQplbmRvYmoKMjIgMCBvYmoKPDwgL0xlbmd0aCAxMTUgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicPY5LEgMhCAX3nOJdwCrBIHKeSaWyMPffDuiYFc2nAXFFRVFGYXewG0wcbyYfi350anNRTG4orYNHuKm9IufmuIi5BZqj172yrIJn739mPsg9UepBkU2aSm2wGLI0R+xRRfwU/QyhX+fFSV/63OYPJeEKZW5kc3RyZWFtCmVuZG9iagoyMyAwIG9iago8PCAvTGVuZ3RoIDE3MCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw9kEsSwyAMQ/ecQkcA/4DztNPpgtx/W8uZdIMUY8svRFd07JWHx8aUjfdoY0+ELVzldBpOUxmPi7tmXaDLYTLTb7yaucBUYZHV7KL6GLyh86xmh69VMzGEN5kSGmAqd3IP9fWnOO3bkpBsV2HQnRqkszDMkfw9EFNz0HOIkfwjX3JrYdCZ5hcXLasZrWVM0exhqmwtDOqNQXfK9dR6rvMwEe/zA99BPmQKZW5kc3RyZWFtCmVuZG9iagoyNCAwIG9iago8PCAvTGVuZ3RoIDMwNyAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw9kktuAzEMQ/c+hS4QwPrZnvOkKLqY3n/bJyXpihzZFkVqlrpMWVMekDSThH/p8HCxnfI7bM9mZuBaopeJ5ZTn0BVi7qJ82cxGXVknxeqEZjq36FE5Fwc2Taqfqyyl3S54Dtcmnlv2ET+80KAe1DUuCTd0V6NlKTRjqvt/0nv8jDLgakxdbFKrex88XkRV6OgHR4kiY5cX5+NBCelKwmhaiJV3RQNB7vK0ynsJ7tveasiyB6mYzjspZrDrdFIubheHIR7I8qjw5aPYa0LP+LArJfRI2IYzcifuaMbm1MjikP7ejQRLj65oIfPgr27WLmC8UzpFYmROcqxpi1VO91AU07nDvQwQ9WxFQylzkdXqX8POC2uWbBZ4SvoFHqPdJksOVtnbqE7vrTzZ0PcfWtd0HwplbmRzdHJlYW0KZW5kb2JqCjI1IDAgb2JqCjw8IC9MZW5ndGggMjMyIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDVRSW7EMAy7+xX8wADW7rwnxaCH9v/XUsoUCEAltrglYmMjAi8x+DmI3PiSNaMmfmdyV/wsT4VHwq3gSRSBl+FedoLLG8ZlPw4zH7yXVs6kxpMMyEU2PTwRMtglEDowuwZ12Gbaib4h4bMjUs1GltPXEvTSKgTKU7bf6YISbav6c/usC2372hNOdnvqSeUTiOeWrMBl4xWTxVgGPVG5SzF9kOpsoSehvCifg2w+aohElyhn4InBwSjQDuy57WfiVSFoXd2nbWOoRkrH078NTU2SCPlECWe2NO4W/n/Pvb7X+w9OIVQRCmVuZHN0cmVhbQplbmRvYmoKMjYgMCBvYmoKPDwgL0xlbmd0aCAyNDkgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicPVA7jkQhDOs5hS/wJPIjcB5Gqy1m79+uA5opUEx+tjMk0BGBRwwxlK/jJa2groG/i0LxbuLrg8Igq0NSIM56D4h07KY2kRM6HZwzP2E3Y47ARTEGnOl0pj0HJjn7wgqEcxtl7FZIJ4mqIo7qM44pnip7n3gWLO3INlsnkj3kIOFSUonJpZ+Uyj9typQKOmbRBCwSueBkE004y7tJUowZlDLqHqZ2In2sPMijOuhkTc6sI5nZ00/bmfgccLdf2mROlcd0Hsz4nLTOgzkVuvfjiTYHTY3a6Oz3E2kqL1K7HVqdfnUSld0Y5xgSl2d/Gd9k//kH/odaIgplbmRzdHJlYW0KZW5kb2JqCjI3IDAgb2JqCjw8IC9MZW5ndGggMzk1IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD1SS27FQAjb5xRcoNLwm895UlXdvPtva0NSqSq8iTHGMH3KkLnlS10ScYXJt16uWzymfC5bWpl5iLuLjSU+ttyX7iG2XXQusTgdR/ILMp0qRKjNqtGh+EKWhQeQTvChC8J9Of7jL4DB17ANuOE9MkGwJOYpQsZuURmaEkERYeeRFaikUJ9Zwt9R7uv3MgVqb4ylC2Mc9Am0BUJtSMQC6kAAROyUVK2QjmckE78V3WdiHGDn0bIBrhlURJZ77MeIqc6ojLxExD5PTfoolkwtVsZuUxlf/JSM1Hx0BSqpNPKU8tBVs9ALWIl5EvY5/Ej459ZsIYY6btbyieUfM8UyEs5gSzlgoZfjR+DbWXURrh25uM50gR+V1nBMtOt+yPVP/nTbWs11vHIIokDlTUHwuw6uRrHExDI+nY0peqIssBqavEYzwWEQEdb3w8gDGv1yvBA0p2sitFgim7ViRI2KbHM9vQTWTO/FOdbDE8Js753WobIzMyohgtq6hmrrQHazvvNwtp8/M+iibQplbmRzdHJlYW0KZW5kb2JqCjI4IDAgb2JqCjw8IC9MZW5ndGggNzQgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicszC2UDBQMDQwUzA0N1IwNzZSMDE1UUgx5AIJgZi5XDDBHDDLGKgsByyLYEFkM8BsI1NTqB4QC6LHEK4SwYLIZnClAQBRvhkWCmVuZHN0cmVhbQplbmRvYmoKMjkgMCBvYmoKPDwgL0xlbmd0aCAyNDkgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTVFJigMwDLvnFfpAIV6TvKdDmUPn/9fKDoU5BAmvkpOWmFgLDzGEHyw9+JEhczf9G36i2btZepLJ2f+Y5yJTUfhSqC5iQl2IG8+hEfA9oWsSWbG98Tkso5lzvgcfhbgEM6EBY31JMrmo5pUhE04MdRwOWqTCuGtiw+Ja0TyN3G77RmZlJoQNj2RC3BiAiCDrArIYLJQ2NhMyWc4D7Q3JDVpg16kbUYuCK5TWCXSiVsSqzOCz5tZ2N0Mt8uCoffH6aFaXYIXRS/VYeF+FPpipmXbukkJ64U07IsweCqQyOy0rtXvE6m6B+j/LUvD9yff4Ha8PzfxcnAplbmRzdHJlYW0KZW5kb2JqCjMwIDAgb2JqCjw8IC9MZW5ndGggOTQgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicRY3BEcAgCAT/VEEJCgraTyaTh/b/jRAyfGDnDu6EBQu2eUYfBZUmXhVYB0pj3FCPQL3hci3J3AUPcCd/2tBUnJbTd2mRSVUp3KQSef8OZyaQqHnRY533C2P7IzwKZW5kc3RyZWFtCmVuZG9iagozMSAwIG9iago8PCAvTGVuZ3RoIDM0MSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxFUktuRDEI279TcIFI4ZeQ87Squpjef1ubTNXN4AlgbHjLU6ZkyrC5JSMk15RPfSJDrKb8NHIkIqb4SQkFdpWPx2tLrI3skagUn9rx47H0RqbZFVr17tGlzaJRzcrIOcgQoZ4VurJ71A7Z8HpcSLrvlM0hHMv/UIEsZd1yCiVBW9B37BHfDx2ugiuCYbBrLoPtZTLU//qHFlzvffdixy6AFqznvsEOAKinE7QFyBna7jYpaABVuotJwqPyem52omyjVen5HAAzDjBywIglWx2+0d4Aln1d6EWNiv0rQFFZQPzI1XbB3jHJSHAW5gaOvXA8xZlwSzjGAkCKveIYevAl2OYvV66ImvAJdbpkL7zCntrm50KTCHetAA5eZMOtq6Oolu3pPIL2Z0VyRozUizg6IZJa0jmC4tKgHlrjXDex4m0jsblX3+4f4ZwvXPbrF0vshMQKZW5kc3RyZWFtCmVuZG9iagozMiAwIG9iago8PCAvTGVuZ3RoIDE2NCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxFkMdxBTEMQ++qAiUwgAr1rMfzD+v+r4b000F6GEIMYk/CsFxXcWF0w4+3LTMNf0cZ7sb6MmO81VggJ+gDDJGJq9Gk+nbFGar05NVirqOiXC86IhLMkuOrQCN8OrLHk7a2M/10Xh/sIe8T/yoq525hAS6q7kD5Uh/x1I/ZUeqaoY8qK2seatpXhF0RSts+LqcyTt29A1rhvZWrPdrvPx52OvIKZW5kc3RyZWFtCmVuZG9iagozMyAwIG9iago8PCAvTGVuZ3RoIDQ3IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nDMyt1AwULA0ARKGFiYK5mYGCimGXJYQVi4XTCwHzALRlnAKIp7BlQYAuWcNJwplbmRzdHJlYW0KZW5kb2JqCjM0IDAgb2JqCjw8IC9MZW5ndGggMjU4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nEWRS3IEIAhE956CI4D85DyTSmUxuf82Dc5kNnaXqP2ESiOmEiznFHkwfcnyzWS26Xc5VjsbBRRFKJjJVeixAqs7U8SZa4lq62Nl5LjTOwbFG85dOalkcaOMdVR1KnBMz5X1Ud35dlmUfUcOZQrYrHMcbODKbcMYJ0abre4O94kgTydTR8XtINnwByeNfZWrK3CdbPbRSzAOBP1CE5jki0DrDIHGzVP05BLs4+N254Fgb3kRSNkQyJEhGB2Cdp1c/+LW+b3/cYY7z7UZrhzv4neY1nbHX2KSFXMBi9wpqOdrLlrXGTrekzPH5Kb7hs65YJe7g0zv+T/Wz/r+Ax4pZvoKZW5kc3RyZWFtCmVuZG9iagozNSAwIG9iago8PCAvTGVuZ3RoIDE2MyAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxFkDsSAyEMQ3tOoSP4IwM+z2YyKTb3b2PYbFLA01ggg7sTgtTagonogoe2Jd0F760EZ2P86TZuNRLkBHWAVqTjaJRSfbnFaZV08Wg2cysLrRMdZg56lKMZoBA6Fd7touRypu7O+UNw9V/1v2LdOZuJgcnKHQjN6lPc+TY7orq6yf6kx9ys134r7FVhaVlLywm3nbtmQAncUznaqz0/Hwo69gplbmRzdHJlYW0KZW5kb2JqCjM2IDAgb2JqCjw8IC9MZW5ndGggMjE4IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD1QuY0EMQzLXYUaWMB67alnFotLpv/0SPn2ItEWRVIqNZmSKS91lCVZU946fJbEDnmG5W5kNiUqRS+TsCX30ArxfYnmFPfd1ZazQzSXaDl+CzMqqhsd00s2mnAqE7qg3MMz+g1tdANWhx6xWyDQpGDXtiByxw8YDMGZE4siDEpNBv+uco+fXosbPsPxQxSRkg7mNf9Y/fJzDa9TjyeRbm++4l6cqQ4DERySmrwjXVixLhIRaTVBTc/AWi2Au7de/hu0I7oMQPaJxHGaUo6hv2twpc8v5SdT2AplbmRzdHJlYW0KZW5kb2JqCjM3IDAgb2JqCjw8IC9UeXBlIC9YT2JqZWN0IC9TdWJ0eXBlIC9Gb3JtIC9CQm94IFsgLTEwMjEgLTQ2MyAxNzk0IDEyMzMgXQovTGVuZ3RoIDE3MyAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw1kDsOAyEMRHtO4QtEwn84z0pRis3924zNpmGeGGN7GBKbXqz0HazaFEGrT8mgawDUhTaTmRKbkFviXnQ13YP/XiyUcqukoqaIVUimUUAyS66hqAYoBrDtVhWHYb6b7qbybEuVuq/zNHQWRGR3Lj2zimp6oHdt4zufTWPrs2k+XiJ0hSo9KYuQOif3HzhSl2KjXE0mFY6Mz1wYU+tC3dr//+M1PuP9A5oyP+YKZW5kc3RyZWFtCmVuZG9iagozOCAwIG9iago8PCAvTGVuZ3RoIDgzIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nEWMuw3AMAhEe6ZgBH4m9j5RlMLevw0QJW64J909XB0JmSluM8NDBp4MLIZdcYH0ljALXEdQjp3so2HVvuoEjfWmUvPvD5Se7KzihusBAkIaZgplbmRzdHJlYW0KZW5kb2JqCjM5IDAgb2JqCjw8IC9MZW5ndGggMjM5IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nE1QyW0EMQz7uwo1MMDoHLseB4s8sv1/Q8oJkpdoS+Kh8pRblspl9yM5b8m65UOHTpVp8m7Qza+x/qMMAnb/UFQQrSWxSsxc0m6xNEkv2cM4jZdrtY7nqXuEWaN48OPY0ymB6T0ywWazvTkwqz3ODpBOuMav6tM7lSQDibqQ80KlCuse1CWijyvbmFKdTi3lGJef6Ht8jgA9xd6N3NHHyxeMRrUtqNFqlTgPMBNT0ZVxq5GBlBMGQ2dHVzQLpcjKekI1wo05oZm9w3BgA8uzhKSlrVK8D2UB6AJd2jrjNEqCjgDC3yiM9foGqvxeNwplbmRzdHJlYW0KZW5kb2JqCjQwIDAgb2JqCjw8IC9MZW5ndGggMTUwIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD1POQ7DMAzb/Qp+IIB1WLbekyLokP5/reigHQQRoHjIsqNjBQ4xgUnHHImXtB/8NI1ALIOaI3pCxTAscDZJgYdBVklXPlucTCG1BV5I+NYUPBtNZIKex4gduJPJ6APvUluxdegB7RBVJF2zDGOxrbpwPWEENcV6Feb1MGOJkkefVUvrAQUT+NL5f+5u73Z9AWDFMF0KZW5kc3RyZWFtCmVuZG9iago0MSAwIG9iago8PCAvTGVuZ3RoIDE1MSAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJw1j8sNwzAMQ++aggsE0M+yPE+KoId0/2slpwUMmDDJJ9kWg5GMQ0xg7Jhj4SVUT60+JCO3ukk5EKlQNwRPaEwMM5ykS+CV6b5lPLd4Oa3UBZ2QyN1ZbTREGc08hqOn7BVO+i9zk6iVGWUOyKxT3U7IyoIVmBfUct/PuK1yoRMetivDojvFiHKbGWn4/e+kN11f3Hgw1QplbmRzdHJlYW0KZW5kb2JqCjQyIDAgb2JqCjw8IC9MZW5ndGggNTEgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicMza0UDBQMDQwB5JGhkCWkYlCiiEXSADEzOWCCeaAWQZAGqI4B64mhyuDKw0A4bQNmAplbmRzdHJlYW0KZW5kb2JqCjQzIDAgb2JqCjw8IC9MZW5ndGggMjQzIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nE1Ru60DMQzrPYUWOMD62b55Lnh4xWX/NqScBKlEQxRJycNTumTKYX1KRkiOLg9tGktsujw3QlOHioKpa4nqlKuZpsxTLE3Q895ZruYY4HtVN9Tf9IheApFRglVhgQ6QO7hg+NlrJmxRCyIxhlAzgGnCCnO4EjEEGYy1ZxiUKgxO1c8qV/svp2XYKrB4MJ0iP7KaaKdfuhx46ykHQtjclbt6IU0I7o0GY8wsXHepsp0AHEx0mYmMWLwNx9MhDA1emgascNaNmCCxGyOlD14HGdOwd0UedbcY8b5bxpS71c99UX3mXe0fCMEbJ/h7AcobXV4KZW5kc3RyZWFtCmVuZG9iago0NCAwIG9iago8PCAvTGVuZ3RoIDE2MCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJxFkDkSAzEIBHO9gidIXIL3rMu1wfr/qQfWR6LpAjQcuhZNynoUaD7psUahutBr6CxKkkTBFpIdUKdjiDsoSExIY5JIth6DI5pYs12YmVQqs1LhtGnFwr/ZWtXIRI1wjfyJ6QZU/E/qXJTwTYOvkjH6GFS8O4OMSfheRdxaMe3+RDCxGfYJb0UmBYSJsanZvs9ghsz3Ctc4x/MNTII36wplbmRzdHJlYW0KZW5kb2JqCjQ1IDAgb2JqCjw8IC9MZW5ndGggMzM0IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nC1SS3LFIAzbcwpdoDP4B+Q86XS6eL3/tpKTRUYOYPQx5YaJSnxZILej1sS3jcxAheGvq8yFz0jbyDqIy5CLuJIthXtELOQxxDzEgu+r8R4e+azMybMHxi/Zdw8r9tSEZSHjxRnaYRXHYRXkWLB1Iap7eFOkw6kk2OOL/z7Fcy0ELXxG0IBf5J+vjuD5khZp95ht0656sEw7qqSwHGxPc14mX1pnuToezwfJ9q7YEVK7AhSFuTPOc+Eo01ZGtBZ2NkhqXGxvjv1YStCFblxGiiOQn6kiPKCkycwmCuKPnB5yKgNh6pqudHIbVXGnnsw1m4u3M0lm675IsZnCeV04s/4MU2a1eSfPcqLUqQjvsWdL0NA5rp69lllodJsTvKSEz8ZOT06+VzPrITkVCaliWlfBaRSZYgnbEl9TUVOaehn++/Lu8Tt+/gEsc3xzCmVuZHN0cmVhbQplbmRvYmoKNDYgMCBvYmoKPDwgL0xlbmd0aCAzMjAgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicNVJLbgUxCNvPKbhApfBPzvOqqou++29rE70VTDBg4ykvWdJLvtQl26XD5Fsf9yWxQt6P7ZrMUsX3FrMUzy2vR88Rty0KBFETPViZLxUi1M/06DqocEqfgVcItxQbvINJAINq+AcepTMgUOdAxrtiMlIDgiTYc2lxCIlyJol/pLye3yetpKH0PVmZy9+TS6XQHU1O6AHFysVJoF1J+aCZmEpEkpfrfbFC9IbAkjw+RzHJgOw2iW2iBSbnHqUlzMQUOrDHArxmmtVV6GDCHocpjFcLs6gebPJbE5WkHa3jGdkw3sswU2Kh4bAF1OZiZYLu5eM1r8KI7VGTXcNw7pbNdwjRaP4bFsrgYxWSgEensRINaTjAiMCeXjjFXvMTOQ7AiGOdmiwMY2gmp3qOicDQnrOlYcbHHlr18w9U6XyHCmVuZHN0cmVhbQplbmRvYmoKNDcgMCBvYmoKPDwgL0xlbmd0aCAxOCAvRmlsdGVyIC9GbGF0ZURlY29kZSA+PgpzdHJlYW0KeJwzNrRQMIDDFEOuNAAd5gNSCmVuZHN0cmVhbQplbmRvYmoKNDggMCBvYmoKPDwgL0xlbmd0aCAyNTEgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicLVFJcgNBCLvPK/SEZqffY5crh+T/1wjKBwYNi0B0WuKgjJ8gLFe85ZGraMPfMzGC3wWHfivXbVjkQFQgSWNQNaF28Xr0HthxmAnMk9awDGasD/yMKdzoxeExGWe312XUEOxdrz2ZQcmsXMQlExdM1WEjZw4/mTIutHM9NyDnRliXYZBuVhozEo40hUghhaqbpM4EQRKMrkaNNnIU+6Uvj3SGVY2oMexzLW1fz004a9DsWKzy5JQeXXEuJxcvrBz09TYDF1FprPJASMD9bg/1c7KT33hL584W0+N7zcnywlRgxZvXbkA21eLfvIjj+4yv5+f5/ANfYFuICmVuZHN0cmVhbQplbmRvYmoKNDkgMCBvYmoKPDwgL0xlbmd0aCAxNzQgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicTZBJDkMhDEP3nMIXqIQzwOc8v6q6aO+/rUMHdYH85CBwPDzQcSQudGTojI4rmxzjwLMgY+LROP/JuD7EMUHdoi1Yl3bH2cwSc8IyMQK2RsnZPKLAD8dcCBJklx++wCAiXY/5VvNZk/TPtzvdj7q0Zl89osCJ7AjFsAFXgP26x4FLwvle0+SXKiVjE4fygeoiUjY7oRC1VOxyqoqz3ZsrcBX0/NFD7u0FtSM83wplbmRzdHJlYW0KZW5kb2JqCjUwIDAgb2JqCjw8IC9MZW5ndGggNTQgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicMzUwUDBQ0LVU0DUyNlUwNQSyDc1MFVIMueDsXAgTJJ/DBVMJYYGkcxAqc7gyuNIAc1EPjwplbmRzdHJlYW0KZW5kb2JqCjUxIDAgb2JqCjw8IC9MZW5ndGggNzUgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicM7U0UjBQMDYAEqZmRgqmJuYKKYZcQD6IlctlaGQKZuVwGVmaKVhYABkmZuZQIZiGHC5jU3OgAUBFxqZgGqo/hyuDKw0AlZAS7wplbmRzdHJlYW0KZW5kb2JqCjUyIDAgb2JqCjw8IC9MZW5ndGggMTQxIC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD2PwQ7DMAhD7/kK/0Ck2CmhfE+naofu/68jS7sLegJjjIXQ0BuqmsOGYJvjxdIlVGv4FMVAJTfImWAOpaTSHUeRemI4GFwetBuO4rHo+hG7kmZ90MZCuiVogHusU2ncpnETxB01Beop6pyjvBC5n6ln2DSS3TSzknO4Db97z1PX/6ervMv5Bb13Lv4KZW5kc3RyZWFtCmVuZG9iago1MyAwIG9iago8PCAvTGVuZ3RoIDc2IC9GaWx0ZXIgL0ZsYXRlRGVjb2RlID4+CnN0cmVhbQp4nD2MOw6AMAxD95zCR2h+JAdCiIHef6UptIv99CTbxdFgWpECt8DJ5D6p03LPJDt8EJsh5FcbWrWuytKaDIuajL8N391N1wumOBfACmVuZHN0cmVhbQplbmRvYmoKNTQgMCBvYmoKPDwgL0xlbmd0aCAyMTUgL0ZpbHRlciAvRmxhdGVEZWNvZGUgPj4Kc3RyZWFtCnicNVE5DgMhDOz3Ff5AJIwveE+iKM3+v82M0VYewVyGtJQhmfJSk6gh5VM+epkunLrc18xqNOeWtC1zgLi2vC+tksCJZoiDwWmYuAGaPAFD19GoUUMXHtDUpVMosNwEPoq3bg/dY7WBl7Yh54kgYigZLEHNqUUTFm3PJ6Q1v16LG96X7d3IU6XGlhiBBgFWOBzX6NfwlT1PJtF0FTLUqzXLGAkTRSI8+Y6m1RPrWjTSMhLUxhGsagO8O/0wTgAAE3HLAmSfSpSz5MRvsfSzBlf6/gGfR1SWCmVuZHN0cmVhbQplbmRvYmoKMTUgMCBvYmoKPDwgL1R5cGUgL0ZvbnQgL0Jhc2VGb250IC9CTVFRRFYrRGVqYVZ1U2FucyAvRmlyc3RDaGFyIDAgL0xhc3RDaGFyIDI1NQovRm9udERlc2NyaXB0b3IgMTQgMCBSIC9TdWJ0eXBlIC9UeXBlMyAvTmFtZSAvQk1RUURWK0RlamFWdVNhbnMKL0ZvbnRCQm94IFsgLTEwMjEgLTQ2MyAxNzk0IDEyMzMgXSAvRm9udE1hdHJpeCBbIDAuMDAxIDAgMCAwLjAwMSAwIDAgXQovQ2hhclByb2NzIDE2IDAgUgovRW5jb2RpbmcgPDwgL1R5cGUgL0VuY29kaW5nCi9EaWZmZXJlbmNlcyBbIDMyIC9zcGFjZSA0MCAvcGFyZW5sZWZ0IC9wYXJlbnJpZ2h0IDQ2IC9wZXJpb2QgNDggL3plcm8gL29uZSAvdHdvIDUyCi9mb3VyIC9maXZlIC9zaXggNTYgL2VpZ2h0IDYxIC9lcXVhbCA2NyAvQyA2OSAvRSAvRiAvRyAvSCA3NCAvSiA4MCAvUCA5NQovdW5kZXJzY29yZSA5NyAvYSA5OSAvYyAxMDEgL2UgMTAzIC9nIC9oIDEwOCAvbCAvbSAvbiAvbyAvcCAvcSAvciAvcyAxMTcgL3UKL3YgMTIxIC95IC96IF0KPj4KL1dpZHRocyAxMyAwIFIgPj4KZW5kb2JqCjE0IDAgb2JqCjw8IC9UeXBlIC9Gb250RGVzY3JpcHRvciAvRm9udE5hbWUgL0JNUVFEVitEZWphVnVTYW5zIC9GbGFncyAzMgovRm9udEJCb3ggWyAtMTAyMSAtNDYzIDE3OTQgMTIzMyBdIC9Bc2NlbnQgOTI5IC9EZXNjZW50IC0yMzYgL0NhcEhlaWdodCAwCi9YSGVpZ2h0IDAgL0l0YWxpY0FuZ2xlIDAgL1N0ZW1WIDAgL01heFdpZHRoIDEzNDIgPj4KZW5kb2JqCjEzIDAgb2JqClsgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAKNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCA2MDAgNjAwIDYwMCAzMTggNDAxIDQ2MCA4MzggNjM2Cjk1MCA3ODAgMjc1IDM5MCAzOTAgNTAwIDgzOCAzMTggMzYxIDMxOCAzMzcgNjM2IDYzNiA2MzYgNjM2IDYzNiA2MzYgNjM2IDYzNgo2MzYgNjM2IDMzNyAzMzcgODM4IDgzOCA4MzggNTMxIDEwMDAgNjg0IDY4NiA2OTggNzcwIDYzMiA1NzUgNzc1IDc1MiAyOTUKMjk1IDY1NiA1NTcgODYzIDc0OCA3ODcgNjAzIDc4NyA2OTUgNjM1IDYxMSA3MzIgNjg0IDk4OSA2ODUgNjExIDY4NSAzOTAgMzM3CjM5MCA4MzggNTAwIDUwMCA2MTMgNjM1IDU1MCA2MzUgNjE1IDM1MiA2MzUgNjM0IDI3OCAyNzggNTc5IDI3OCA5NzQgNjM0IDYxMgo2MzUgNjM1IDQxMSA1MjEgMzkyIDYzNCA1OTIgODE4IDU5MiA1OTIgNTI1IDYzNiAzMzcgNjM2IDgzOCA2MDAgNjM2IDYwMCAzMTgKMzUyIDUxOCAxMDAwIDUwMCA1MDAgNTAwIDEzNDIgNjM1IDQwMCAxMDcwIDYwMCA2ODUgNjAwIDYwMCAzMTggMzE4IDUxOCA1MTgKNTkwIDUwMCAxMDAwIDUwMCAxMDAwIDUyMSA0MDAgMTAyMyA2MDAgNTI1IDYxMSAzMTggNDAxIDYzNiA2MzYgNjM2IDYzNiAzMzcKNTAwIDUwMCAxMDAwIDQ3MSA2MTIgODM4IDM2MSAxMDAwIDUwMCA1MDAgODM4IDQwMSA0MDEgNTAwIDYzNiA2MzYgMzE4IDUwMAo0MDEgNDcxIDYxMiA5NjkgOTY5IDk2OSA1MzEgNjg0IDY4NCA2ODQgNjg0IDY4NCA2ODQgOTc0IDY5OCA2MzIgNjMyIDYzMiA2MzIKMjk1IDI5NSAyOTUgMjk1IDc3NSA3NDggNzg3IDc4NyA3ODcgNzg3IDc4NyA4MzggNzg3IDczMiA3MzIgNzMyIDczMiA2MTEgNjA1CjYzMCA2MTMgNjEzIDYxMyA2MTMgNjEzIDYxMyA5ODIgNTUwIDYxNSA2MTUgNjE1IDYxNSAyNzggMjc4IDI3OCAyNzggNjEyIDYzNAo2MTIgNjEyIDYxMiA2MTIgNjEyIDgzOCA2MTIgNjM0IDYzNCA2MzQgNjM0IDU5MiA2MzUgNTkyIF0KZW5kb2JqCjE2IDAgb2JqCjw8IC9DIDE3IDAgUiAvRSAxOCAwIFIgL0YgMTkgMCBSIC9HIDIwIDAgUiAvSCAyMSAwIFIgL0ogMjIgMCBSIC9QIDIzIDAgUgovYSAyNCAwIFIgL2MgMjUgMCBSIC9lIDI2IDAgUiAvZWlnaHQgMjcgMCBSIC9lcXVhbCAyOCAwIFIgL2ZpdmUgMjkgMCBSCi9mb3VyIDMwIDAgUiAvZyAzMSAwIFIgL2ggMzIgMCBSIC9sIDMzIDAgUiAvbSAzNCAwIFIgL24gMzUgMCBSIC9vIDM2IDAgUgovb25lIDM4IDAgUiAvcCAzOSAwIFIgL3BhcmVubGVmdCA0MCAwIFIgL3BhcmVucmlnaHQgNDEgMCBSIC9wZXJpb2QgNDIgMCBSCi9xIDQzIDAgUiAvciA0NCAwIFIgL3MgNDUgMCBSIC9zaXggNDYgMCBSIC9zcGFjZSA0NyAwIFIgL3R3byA0OCAwIFIKL3UgNDkgMCBSIC91bmRlcnNjb3JlIDUwIDAgUiAvdiA1MSAwIFIgL3kgNTIgMCBSIC96IDUzIDAgUiAvemVybyA1NCAwIFIgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL0YxIDE1IDAgUiA+PgplbmRvYmoKNCAwIG9iago8PCAvQTEgPDwgL1R5cGUgL0V4dEdTdGF0ZSAvQ0EgMCAvY2EgMSA+PgovQTIgPDwgL1R5cGUgL0V4dEdTdGF0ZSAvQ0EgMSAvY2EgMSA+PiA+PgplbmRvYmoKNSAwIG9iago8PCA+PgplbmRvYmoKNiAwIG9iago8PCA+PgplbmRvYmoKNyAwIG9iago8PCAvRjEtRGVqYVZ1U2Fucy1vbWVnYSAzNyAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFsgMTEgMCBSIF0gL0NvdW50IDEgPj4KZW5kb2JqCjU1IDAgb2JqCjw8IC9DcmVhdG9yIChNYXRwbG90bGliIHYzLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcpCi9Qcm9kdWNlciAoTWF0cGxvdGxpYiBwZGYgYmFja2VuZCB2My4xMC4xKQovQ3JlYXRpb25EYXRlIChEOjIwMjUwNjA5MDgxMTA1KzA2JzAwJykgPj4KZW5kb2JqCnhyZWYKMCA1NgowMDAwMDAwMDAwIDY1NTM1IGYgCjAwMDAwMDAwMTYgMDAwMDAgbiAKMDAwMDAxNDU0OCAwMDAwMCBuIAowMDAwMDE0MzI2IDAwMDAwIG4gCjAwMDAwMTQzNTggMDAwMDAgbiAKMDAwMDAxNDQ1NyAwMDAwMCBuIAowMDAwMDE0NDc4IDAwMDAwIG4gCjAwMDAwMTQ0OTkgMDAwMDAgbiAKMDAwMDAwMDA2NSAwMDAwMCBuIAowMDAwMDAwMzQxIDAwMDAwIG4gCjAwMDAwMDI1MzMgMDAwMDAgbiAKMDAwMDAwMDIwOCAwMDAwMCBuIAowMDAwMDAyNTEyIDAwMDAwIG4gCjAwMDAwMTI4MjMgMDAwMDAgbiAKMDAwMDAxMjYxNiAwMDAwMCBuIAowMDAwMDEyMDc4IDAwMDAwIG4gCjAwMDAwMTM4NzYgMDAwMDAgbiAKMDAwMDAwMjU1MyAwMDAwMCBuIAowMDAwMDAyODYxIDAwMDAwIG4gCjAwMDAwMDMwMTQgMDAwMDAgbiAKMDAwMDAwMzE2MiAwMDAwMCBuIAowMDAwMDAzNDgyIDAwMDAwIG4gCjAwMDAwMDM2MzMgMDAwMDAgbiAKMDAwMDAwMzgyMSAwMDAwMCBuIAowMDAwMDA0MDY0IDAwMDAwIG4gCjAwMDAwMDQ0NDQgMDAwMDAgbiAKMDAwMDAwNDc0OSAwMDAwMCBuIAowMDAwMDA1MDcxIDAwMDAwIG4gCjAwMDAwMDU1MzkgMDAwMDAgbiAKMDAwMDAwNTY4NSAwMDAwMCBuIAowMDAwMDA2MDA3IDAwMDAwIG4gCjAwMDAwMDYxNzMgMDAwMDAgbiAKMDAwMDAwNjU4NyAwMDAwMCBuIAowMDAwMDA2ODI0IDAwMDAwIG4gCjAwMDAwMDY5NDMgMDAwMDAgbiAKMDAwMDAwNzI3NCAwMDAwMCBuIAowMDAwMDA3NTEwIDAwMDAwIG4gCjAwMDAwMDc4MDEgMDAwMDAgbiAKMDAwMDAwODEwOCAwMDAwMCBuIAowMDAwMDA4MjYzIDAwMDAwIG4gCjAwMDAwMDg1NzUgMDAwMDAgbiAKMDAwMDAwODc5OCAwMDAwMCBuIAowMDAwMDA5MDIyIDAwMDAwIG4gCjAwMDAwMDkxNDUgMDAwMDAgbiAKMDAwMDAwOTQ2MSAwMDAwMCBuIAowMDAwMDA5Njk0IDAwMDAwIG4gCjAwMDAwMTAxMDEgMDAwMDAgbiAKMDAwMDAxMDQ5NCAwMDAwMCBuIAowMDAwMDEwNTg0IDAwMDAwIG4gCjAwMDAwMTA5MDggMDAwMDAgbiAKMDAwMDAxMTE1NSAwMDAwMCBuIAowMDAwMDExMjgxIDAwMDAwIG4gCjAwMDAwMTE0MjggMDAwMDAgbiAKMDAwMDAxMTY0MiAwMDAwMCBuIAowMDAwMDExNzkwIDAwMDAwIG4gCjAwMDAwMTQ2MDggMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA1NiAvUm9vdCAxIDAgUiAvSW5mbyA1NSAwIFIgPj4Kc3RhcnR4cmVmCjE0NzY3CiUlRU9GCg==", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2025-06-09T08:11:05.371309\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.10.1, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" + "cell_type": "code", + "execution_count": 4, + "id": "d3bb2054", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d3bb2054", + "outputId": "e08369a5-8a22-4cd2-c32f-691c62ef08d2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Symbolic plasma frequency: 2*sqrt(2)*sqrt(E_C*E_J)\n" + ] + } ], - "text/plain": [ - "
" + "source": [ + "# Define the plasma frequency symbolically\n", + "omega_p = sp.sqrt(8 * EJ * EC)\n", + "\n", + "print(\"Symbolic plasma frequency:\", omega_p)" + ] + }, + { + "cell_type": "markdown", + "id": "37a568dc", + "metadata": { + "id": "37a568dc" + }, + "source": [ + "This gives us a general formula for \\(\\omega_p\\), which we can manipulate in all sorts of ways. For example, let’s say we want to know how sensitive the plasma frequency is to changes in \\(E_J\\) and \\(E_C\\). We can do this by taking the partial derivatives:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "79c10d1a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "79c10d1a", + "outputId": "9ce55f92-04d3-4ee7-e1aa-a337e98a0c8f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sensitivity to EJ (dω_p / dE_J): sqrt(2)*sqrt(E_C*E_J)/E_J\n", + "Sensitivity to EC (dω_p / dE_C): sqrt(2)*sqrt(E_C*E_J)/E_C\n" + ] + } + ], + "source": [ + "# Compute the partial derivatives of omega_p with respect to EJ and EC\n", + "sensitivity_EJ = sp.diff(omega_p, EJ)\n", + "sensitivity_EC = sp.diff(omega_p, EC)\n", + "\n", + "print(\"Sensitivity to EJ (dω_p / dE_J):\", sensitivity_EJ)\n", + "print(\"Sensitivity to EC (dω_p / dE_C):\", sensitivity_EC)" + ] + }, + { + "cell_type": "markdown", + "id": "cea88aad", + "metadata": { + "id": "cea88aad" + }, + "source": [ + "These derivatives tell us how much \\(\\omega_p\\) changes if we tweak \\(E_J\\) or \\(E_C\\), which is super helpful for designing qubits with specific frequencies.\n", + "\n", + "### Visualizing Sensitivities\n", + "\n", + "To better understand these sensitivities, let’s plot how they change as we vary \\(E_J\\), keeping \\(E_C\\) fixed. This will give us a visual sense of which parameter has a bigger impact on the plasma frequency." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5bb7ba29", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "5bb7ba29", + "outputId": "1ad674e9-2ec9-4879-d0ec-b804e3595077" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Fix EC to a numerical value, say 0.25 GHz\n", + "EC_fixed = 0.25\n", + "\n", + "# Create numerical functions for sensitivities\n", + "sensitivity_EJ_func = sp.lambdify(EJ, sensitivity_EJ.subs(EC, EC_fixed), 'numpy')\n", + "sensitivity_EC_func = sp.lambdify(EJ, sensitivity_EC.subs(EC, EC_fixed), 'numpy')\n", + "\n", + "# Define a range for EJ\n", + "EJ_range = np.linspace(10, 100, 100)\n", + "\n", + "# Compute sensitivities\n", + "sensitivity_EJ_values = sensitivity_EJ_func(EJ_range)\n", + "sensitivity_EC_values = sensitivity_EC_func(EJ_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(EJ_range, sensitivity_EJ_values, label='dω_p / dE_J', color='blue')\n", + "plt.plot(EJ_range, sensitivity_EC_values, label='dω_p / dE_C', color='orange')\n", + "plt.xlabel('E_J (GHz)')\n", + "plt.ylabel('Sensitivity')\n", + "plt.title('Sensitivities of Plasma Frequency to E_J and E_C (E_C = 0.25 GHz)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5379a173", + "metadata": { + "id": "5379a173" + }, + "source": [ + "From this plot, we can see that:\n", + "- The sensitivity to \\(E_J\\) decreases as \\(E_J\\) increases, meaning larger \\(E_J\\) values make \\(\\omega_p\\) less sensitive to changes in \\(E_J\\).\n", + "- The sensitivity to \\(E_C\\) remains relatively constant, indicating that changes in \\(E_C\\) have a consistent impact on \\(\\omega_p\\).\n", + "\n", + "This visualization provides deeper insight into how to tune qubit parameters for desired behavior.\n", + "\n", + "## Combining scqubits and sympy: The Best of Both Worlds\n", + "\n", + "Now, let’s bring scqubits and sympy together to analyze quantum circuits in a powerful way. The catch is that scqubits expects numerical values for parameters like \\(E_J\\) and \\(E_C\\), so we can’t directly use symbols in scqubits calculations. But we can use sympy to derive general relationships and then plug in numbers to connect back to scqubits.\n", + "\n", + "Let’s try defining a Transmon qubit with symbolic parameters to see what happens:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "da8bb5df", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "da8bb5df", + "outputId": "d04ff54e-6774-448b-bdd0-1a3805b70c84" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error: object arrays are not supported\n" + ] + } + ], + "source": [ + "# Try to define a Transmon with symbolic parameters\n", + "try:\n", + " transmon_sym = scq.Transmon(EJ=EJ, EC=EC, ng=0.0, ncut=30)\n", + " evals_sym = transmon_sym.eigenvals()\n", + "except Exception as e:\n", + " print(\"Error:\", e)" + ] + }, + { + "cell_type": "markdown", + "id": "caf08890", + "metadata": { + "id": "caf08890" + }, + "source": [ + "\n", + "As expected, this doesn’t work because scqubits needs numbers, not symbols, to compute things like eigenvalues. So, instead, we’ll use sympy to work with our symbolic expressions and then substitute numerical values when we need to connect to scqubits or create visualizations.\n", + "\n", + "### Example: Solving for \\(E_J\\)\n", + "\n", + "Suppose we want to design a qubit with a plasma frequency of 5 GHz, and we know \\(E_C = 0.25\\) GHz. We can use our symbolic expression for \\(\\omega_p\\) to find the required \\(E_J\\):" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ad90a6ff", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ad90a6ff", + "outputId": "8bdeadc2-18d4-4afb-833b-bac61fc53198" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Required E_J for ω_p = 5 GHz: [12.5000000000000]\n" + ] + } + ], + "source": [ + "# Set the desired plasma frequency\n", + "desired_omega_p = 5.0 # in GHz\n", + "\n", + "# Set a numerical value for EC\n", + "EC_num = 0.25 # in GHz\n", + "\n", + "# Substitute EC into the plasma frequency expression\n", + "omega_p_with_EC = omega_p.subs(EC, EC_num)\n", + "\n", + "# Solve for EJ to achieve the desired omega_p\n", + "solution = sp.solve(omega_p_with_EC - desired_omega_p, EJ)\n", + "\n", + "print(\"Required E_J for ω_p = 5 GHz:\", solution)" + ] + }, + { + "cell_type": "markdown", + "id": "77b51c55", + "metadata": { + "id": "77b51c55" + }, + "source": [ + "This code uses sympy to solve the equation \\(\\sqrt{8 E_J \\cdot 0.25} = 5\\), giving us the value of \\(E_J\\) needed for the desired frequency. Isn’t that cool? We’re using math to design our qubit!\n", + "\n", + "### Visualizing the Relationship\n", + "\n", + "To get a better sense of how \\(\\omega_p\\) depends on \\(E_J\\), let’s create a plot. We’ll use sympy to turn our symbolic expression into a numerical function and then use matplotlib to visualize it:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6b76a985", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "6b76a985", + "outputId": "442076ab-3051-4598-aece-b78eb2dd717f" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert the symbolic expression to a numerical function\n", + "omega_p_func = sp.lambdify(EJ, omega_p_with_EC, 'numpy')\n", + "\n", + "# Define a range of EJ values to explore\n", + "EJ_values = np.linspace(10, 100, 100)\n", + "\n", + "# Compute omega_p for these EJ values\n", + "omega_p_values = omega_p_func(EJ_values)\n", + "\n", + "# Create the plot\n", + "plt.plot(EJ_values, omega_p_values, color='green')\n", + "plt.xlabel('E_J (GHz)')\n", + "plt.ylabel('ω_p (GHz)')\n", + "plt.title('Plasma Frequency vs Josephson Energy (E_C = 0.25 GHz)')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "94654dca", + "metadata": { + "id": "94654dca" + }, + "source": [ + "This plot shows how the plasma frequency changes as we vary \\(E_J\\), with \\(E_C\\) fixed at 0.25 GHz. It’s a great way to visualize the relationship and understand how to tune our qubit for different frequencies." + ] + }, + { + "cell_type": "markdown", + "id": "35dc13df", + "metadata": { + "id": "35dc13df" + }, + "source": [ + "## Working with Non-Commuting Operators in sympy\n", + "\n", + "In quantum mechanics, we often encounter operators that do not commute, meaning the order in which they are applied matters. This is a fundamental concept, for example, in describing position and momentum, or in the context of superconducting qubits, where different operations on the qubit might not commute. `sympy` can also be used to represent and manipulate such non-commuting operators.\n", + "\n", + "To define non-commuting symbols in `sympy`, we use the `commutative=False` argument. Let's define two non-commuting operators, \\(A\\) and \\(B\\):" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "01beeb7e", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "01beeb7e", + "outputId": "08995cba-c2bb-439d-b555-66d0d08999ef" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Is A*B == B*A? Eq(A*B, B*A)\n" + ] + } + ], + "source": [ + "import sympy as sp\n", + "\n", + "# Define non-commuting symbolic variables\n", + "A, B = sp.symbols('A B', commutative=False)\n", + "\n", + "# Let's check if they commute\n", + "print(f\"Is A*B == B*A? {sp.Eq(A*B, B*A)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6056f614", + "metadata": { + "id": "6056f614" + }, + "source": [ + "As expected, `sympy` recognizes that \\(A \\cdot B\\) is not equal to \\(B \\cdot A\\).\n", + "\n", + "Now, let's explore some simple manipulations with these non-commuting operators. For instance, consider the expression \\((A+B)^2\\):" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "277c2ae1", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "277c2ae1", + "outputId": "9bb774f0-9a4f-4056-87fc-a9256d075d5b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expanded expression of (A+B)^2: A*B + A**2 + B*A + B**2\n" + ] + } + ], + "source": [ + "# Expand the expression (A+B)^2\n", + "expression = (A + B)**2\n", + "expanded_expression = sp.expand(expression)\n", + "\n", + "print(f\"Expanded expression of (A+B)^2: {expanded_expression}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2d474bec", + "metadata": { + "id": "2d474bec" + }, + "source": [ + "Notice that the expanded expression includes both \\(A \\cdot B\\) and \\(B \\cdot A\\) terms, which is crucial because they are not equal.\n", + "\n", + "While this is a basic example, the ability to symbolically manipulate non-commuting operators in `sympy` can be powerful when dealing with more complex quantum mechanical expressions or deriving equations of motion for quantum systems. In the context of superconducting qubits, this could be applied to analyzing the effect of sequences of quantum gates, which are represented by non-commuting operators." + ] + }, + { + "cell_type": "markdown", + "id": "-sUwLty88_X5", + "metadata": { + "id": "-sUwLty88_X5" + }, + "source": [ + "## Wrapping It Up\n", + "\n", + "Wow, you’ve made it through!\n", + "\n", + "In this tutorial, we’ve learned how to combine `scqubits` and `sympy` to analyze quantum circuits in two powerful ways:\n", + "- **Numerically**, using scqubits to simulate qubits with specific parameters.\n", + "- **Symbolically**, using sympy to derive general formulas and explore relationships.\n", + "\n", + "This approach gives you a deeper understanding of how qubits work and helps you design quantum systems with the exact properties you want. Pretty amazing, right?\n", + "\n", + "### What’s Next?\n", + "\n", + "If you’re excited to keep exploring, here are some ideas:\n", + "- Try this method with other qubit types, like Fluxonium or Xmon, in scqubits.\n", + "- Dive deeper into sympy by exploring advanced features, like solving differential equations or working with matrices.\n", + "- Combine symbolic results with scqubits’ parameter sweeps to study how changing multiple parameters affects your system.\n", + "- Check out the official documentation for [scqubits](https://scqubits.readthedocs.io/) and [sympy](https://docs.sympy.org/) for more inspiration.\n", + "\n", + "Keep experimenting—you’re well on your way to becoming a quantum computing pro!\n", + "\n", + "Thanks for joining me on this quantum adventure! Have fun exploring scqubits and sympy!" ] - }, - "metadata": {}, - "output_type": "display_data" } - ], - "source": [ - "# Convert the symbolic expression to a numerical function\n", - "omega_p_func = sp.lambdify(EJ, omega_p_with_EC, 'numpy')\n", - "\n", - "# Define a range of EJ values to explore\n", - "EJ_values = np.linspace(10, 100, 100)\n", - "\n", - "# Compute omega_p for these EJ values\n", - "omega_p_values = omega_p_func(EJ_values)\n", - "\n", - "# Create the plot\n", - "plt.plot(EJ_values, omega_p_values, color='green')\n", - "plt.xlabel('E_J (GHz)')\n", - "plt.ylabel('ω_p (GHz)')\n", - "plt.title('Plasma Frequency vs Josephson Energy (E_C = 0.25 GHz)')\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "94654dca", - "metadata": {}, - "source": [ - "This plot shows how the plasma frequency changes as we vary \\(E_J\\), with \\(E_C\\) fixed at 0.25 GHz. It’s a great way to visualize the relationship and understand how to tune our qubit for different frequencies.\n", - "\n", - "## Wrapping It Up\n", - "\n", - "Wow, you’ve made it through! In this tutorial, we’ve learned how to combine `scqubits` and `sympy` to analyze quantum circuits in two powerful ways:\n", - "- **Numerically**, using scqubits to simulate qubits with specific parameters.\n", - "- **Symbolically**, using sympy to derive general formulas and explore relationships.\n", - "\n", - "This approach gives you a deeper understanding of how qubits work and helps you design quantum systems with the exact properties you want. Pretty amazing, right?\n", - "\n", - "### What’s Next?\n", - "\n", - "If you’re excited to keep exploring, here are some ideas:\n", - "- Try this method with other qubit types, like Fluxonium or Xmon, in scqubits.\n", - "- Dive deeper into sympy by exploring advanced features, like solving differential equations or working with matrices.\n", - "- Combine symbolic results with scqubits’ parameter sweeps to study how changing multiple parameters affects your system.\n", - "- Check out the official documentation for [scqubits](https://scqubits.readthedocs.io/) and [sympy](https://docs.sympy.org/) for more inspiration.\n", - "\n", - "Keep experimenting—you’re well on your way to becoming a quantum computing pro!\n", - "\n", - "### Tips for Using Jupyter Notebooks\n", - "\n", - "Since we’re using a Jupyter notebook, here are a few tips to make your experience even better:\n", - "- **Run cells in order**: Jupyter lets you run cells in any order, but running them from top to bottom avoids confusion or errors.\n", - "- **Use keyboard shortcuts**: Try `Shift + Enter` to run a cell, `Esc` to enter command mode, and `A` or `B` to add cells above or below.\n", - "- **Check for errors**: A red outline around a cell means there’s an issue—fix it before moving on.\n", - "- **Save often**: Save your notebook regularly to keep your progress safe.\n", - "\n", - "Thanks for joining me on this quantum adventure! Have fun exploring scqubits and sympy!" - ] - }, - { - "cell_type": "markdown", - "id": "359cffbf", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.10.12" + } }, - "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.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 }