diff --git a/docs/source/conf.py b/docs/source/conf.py index 3faea6833..80929e7e1 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -40,6 +40,7 @@ "sphinx.ext.autodoc", "sphinx.ext.mathjax", "sphinx.ext.napoleon", + "sphinx.ext.autosummary", "sphinx_autodoc_typehints", ] diff --git a/docs/source/conventions.md b/docs/source/conventions.md index 73c7e3b34..34dcd6a19 100644 --- a/docs/source/conventions.md +++ b/docs/source/conventions.md @@ -122,6 +122,11 @@ sample ## Hamiltonians +:::{tip} +This section uses formulas that rely on the [Indexed Operator](#indexed-operator) +notation. +::: + Independently of the mode of operation, the Hamiltonian describing the system can be written as @@ -258,3 +263,21 @@ $$ :::{note} The definitions given for both interaction Hamiltonians are independent of the chosen state vector convention. ::: + +## Notation + +### Indexed Operator + +Whenever an arbitrary operator is written with an index (typically $i$ or $j$), e.g. $\hat{O}_i$, it is implicit that $\hat{O}$ is applied *only* to qudit $i$ while the rest of the qudits are applied the identity operator, $\hat{I}$. Put another way, + +$$ \hat{O}_i = \underset{(1)}{\hat{I}} \otimes \underset{(2)}{\hat{I}} \otimes ... \otimes\ \underset{(i)}{\hat{O}}\ \otimes ... \otimes \underset{(N)}{\hat{I}},$$ + +where $1 \leq i \leq N$. + +This notation is extendable to multiple indices. Take for instance the case with two indices, $\hat{O}_{ij}$ – here, $\hat{O}$ is a two-qudit operator. A good example is the [interaction Hamiltonian](#interaction-hamiltonian) in the `ground-rydberg` basis, which we write as + +$$H^\text{int}_{ij} = \frac{C_6}{R_{ij}^6} \hat{n}_i \hat{n}_j = \frac{C_6}{R_{ij}^6} \left( \underset{(1)}{\hat{I}} \otimes ... \otimes \ \underset{(j)}{\hat{n}}\ \otimes ... \otimes \ \underset{(i)}{\hat{n}} \ \otimes ... \otimes \underset{(N)}{\hat{I}}\right),$$ + +where $1 \leq j < i \leq N$. + +Note that, generally, we cannot write $\hat{O}_{ij}$ in the form used above because $\hat{O}$ might not be separable in a tensor product of two single-qudit operators, but the operator is valid nonetheless. diff --git a/docs/source/files/rydberg_blockade.png b/docs/source/files/rydberg_blockade.png new file mode 100644 index 000000000..84c12c63c Binary files /dev/null and b/docs/source/files/rydberg_blockade.png differ diff --git a/docs/source/index.rst b/docs/source/index.rst index 04fd01dea..a9c5127aa 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -46,7 +46,7 @@ of quantum programs written with Pulser on :doc:`tutorials/creating`. .. toctree:: :maxdepth: 2 - :caption: Installation and First Steps + :caption: Getting Started installation programming @@ -54,15 +54,11 @@ of quantum programs written with Pulser on :doc:`tutorials/creating`. .. toctree:: :maxdepth: 2 - :caption: Fundamental Concepts + :caption: Fundamentals conventions + register hardware - -.. toctree:: - :maxdepth: 2 - :caption: Backend Execution - tutorials/backends .. toctree:: @@ -92,20 +88,11 @@ of quantum programs written with Pulser on :doc:`tutorials/creating`. .. toctree:: :maxdepth: 1 - :caption: Quantum Simulation + :caption: Quantum Simulation & Applications tutorials/afm_prep tutorials/optimization tutorials/xy_spin_chain - tutorials/mw_engineering - tutorials/shadow_est - tutorials/1D_crystals - -.. toctree:: - :maxdepth: 1 - :caption: Other Applications - - tutorials/cz_gate tutorials/qubo .. toctree:: diff --git a/docs/source/programming.md b/docs/source/programming.md index 95f6e9efa..374a5709b 100644 --- a/docs/source/programming.md +++ b/docs/source/programming.md @@ -46,6 +46,10 @@ Here $H(t)$ is the Hamiltonian describing the evolution of the system. For a sys $$ \left|\Psi_f\right> = \exp\left(-\frac{i}{\hbar}\int_0^{\Delta t} H(t) dt\right)\left|\Psi_0\right>$$ +:::{tip} +The equation below uses the [Indexed Operator](conventions.md#indexed-operator) notation. +::: + The Hamiltonian describing the evolution of the system can be written as $$ @@ -65,7 +69,7 @@ and $j$. The driving Hamiltonian describes the effect of a pulse on two energy levels of an individual atom, $|a\rangle$ and $|b\rangle$. A pulse is determined by its duration $\Delta t$, its Rabi frequency $\Omega(t)$, its detuning $\delta(t)$ and its phase $\phi$ (constant along the duration of the pulse). Between $0$ and $\Delta t$, the driving Hamiltonian is: $$ -H^D(t) / \hbar = \frac{\Omega(t)}{2} e^{-j\phi} |a\rangle\langle b| + \frac{\Omega(t)}{2} e^{j\phi} |b\rangle\langle a| - \delta(t) |b\rangle\langle b| +H^D(t) / \hbar = \frac{\Omega(t)}{2} e^{-i\phi} |a\rangle\langle b| + \frac{\Omega(t)}{2} e^{i\phi} |b\rangle\langle a| - \delta(t) |b\rangle\langle b| $$
diff --git a/docs/source/register.ipynb b/docs/source/register.ipynb new file mode 100644 index 000000000..22919265d --- /dev/null +++ b/docs/source/register.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2a6852ac-a3b9-4114-85ac-2be21c6633b0", + "metadata": {}, + "source": [ + "# Register and Rydberg-Atom Interactions" + ] + }, + { + "cell_type": "markdown", + "id": "e6b26e9c", + "metadata": {}, + "source": [ + "*What you will learn:*\n", + "- what is a `Register` and how to create it;\n", + "- why the relative position of the atoms in a `Register` is important;\n", + "- what is the Rydberg blockade;\n", + "- how the design of the `Register` may be influenced by the rest of the `Sequence`;\n", + "- tips on how to design a `Register` for different applications." + ] + }, + { + "cell_type": "markdown", + "id": "979ebffc-2017-4b9c-8aa3-27bceda01d38", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## The `Register`\n", + "\n", + "The `Register` is a group of cold atoms placed in space according to a user-defined configuration. Each atom is in a quantum state encoded in [specific electronic levels](conventions.md#states-and-bases). Usually these are two-level systems and we refer to them as **qubits**.\n", + "\n", + "### Standard definition\n", + "\n", + "There are multiple ways to define a `Register`, the most customizable one being to create a dictionary that associates a name (the key) to a cooordinate (the value).\n", + "\n", + "
\n", + "\n", + "Despite being given as a mapping to `Register`, **the order of the qubits matters** and is preserved. In particular, this order is respected in the [representation of multi-partite quantum states](conventions.md#multi-partite-states). When in doubt, it can be accessed via `Register.qubit_ids`. \n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b039af2-22d5-47ad-bc8a-97ef57737b08", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import pulser\n", + "\n", + "# Manually generate the IDs and coordinates of a 2x2 square with 5μm spacing\n", + "qubits = {\"q0\": [0, 0], \"q1\": [5, 0], \"q2\": [0, 5], \"q3\": [5, 5]}\n", + "reg = pulser.Register(qubits)\n", + "reg.draw()" + ] + }, + { + "cell_type": "markdown", + "id": "66df3519-7d33-4557-8d6d-ac9fb179b380", + "metadata": {}, + "source": [ + "### From coordinates\n", + "\n", + "When it is convenient to label the qubits automatically, the `Register` can also be created from a list of coordinates (using the `Register.from_coordinates` class method). In this case, the qubit ID's are just numbered, starting from 0, in the order they are provided in, with the option of adding a common prefix before each number. Also, it automatically centers the entire array around the origin, an option that can be disabled if desired." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a265ebd-d379-4ba3-b735-bae87216c176", + "metadata": {}, + "outputs": [], + "source": [ + "import pulser\n", + "\n", + "reg2 = pulser.Register.from_coordinates(\n", + " [[0, 0], [5, 0], [0, 5], [5, 5]], # Takes just the coordinates\n", + " prefix=\"q\", # All qubit IDs will start with 'q'\n", + " center=True,\n", + ")\n", + "print(\"(Centered) qubits:\", reg2.qubits)" + ] + }, + { + "cell_type": "markdown", + "id": "5fac062c-b653-4c32-84c9-f72b3b8e8334", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "### From common patterns\n", + "\n", + "Furthermore, there are built-in class methods for creation of common array patterns - for instance, `Register.square()` offers a convenient shortcut to make a register in a centered square configuration, so it does not have to be done manually as done above." + ] + }, + { + "cell_type": "raw", + "id": "38dd64e4-472b-46f7-8617-dbdbcbadb160", + "metadata": { + "editable": true, + "raw_mimetype": "text/restructuredtext", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + ".. currentmodule:: pulser.register.register\n", + "\n", + ".. autosummary::\n", + "\n", + " Register.square\n", + " Register.rectangle\n", + " Register.rectangular_lattice\n", + " Register.triangular_lattice\n", + " Register.hexagon" + ] + }, + { + "cell_type": "markdown", + "id": "a05f8e2d", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "For more information on all the `Register` methods, please refer to the [Register API reference](apidoc/core.rst#pulser.register.register.Register)." + ] + }, + { + "cell_type": "markdown", + "id": "cd280505", + "metadata": {}, + "source": [ + "## Rydberg-Atom Interactions\n", + "\n", + "When an atom is excited to a Rydberg state, nearby atoms interact according to the [interaction Hamiltonian](programming.md#interaction-hamiltonian). The interaction strength is always dependent on the distance between atoms and is stronger the closer they are. Therefore, appropriately selecting the atoms' relative positions is a crucial step in the programming of neutral-atom QPUs. \n", + "\n", + "In the most common case of the [Ising Hamiltonian](programming.md#ising-hamiltonian), the interaction operator is given by\n", + "\n", + "$$\n", + "\\hat{U}_{ij} = \\frac{C_6}{R_{ij}^6} \\hat{n}_i \\hat{n}_j,\n", + "$$\n", + "\n", + "where \n", + "\n", + "- the interaction strength is $\\frac{C_6}{R_{ij}^6}$, where $C_6$ is a coefficient that depends on the principal quantum number of the Rydberg state the atoms are excited to;\n", + "- the entangling operator between atom $i$ and $j$ is $\\hat{n}_i\\hat{n}_j = |r\\rangle\\langle r|_i |r\\rangle\\langle r|_j$. \n", + "\n", + "Note that:\n", + "\n", + "1. The interaction strength scales with $R_{ij}^{-6}$, so it decays rapidly when the distance between the atoms increases.\n", + "2. There is only an interaction when both atoms are excited to their respective Rydberg states, $|r\\rangle_i$ and $|r\\rangle_j$." + ] + }, + { + "cell_type": "markdown", + "id": "7023920c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## The Rydberg Blockade \n", + "\n", + "Consider a system of two atoms, $R$ distance apart, that we want to excite from the $|gg\\rangle$ state to the $|rr\\rangle$ state. To keep things simple, we'll use a global resonant pulse (i.e.$\\delta=0$) with constant Rabi frequency $\\Omega(t) = \\Omega$ and phase $\\phi=0$, so that the [full Hamiltonian](programming.md#hamiltonian-evolves-the-state) is\n", + "\n", + "$$H = \\frac{\\hbar\\Omega}{2}\\left[\\mathbb{I} \\otimes \\sigma_x + \\sigma_x \\otimes \\mathbb{I} \\right] + \\frac{C_6}{R^6} |rr\\rangle\\langle rr|,$$\n", + "\n", + "where $\\sigma_x = |g\\rangle\\langle r| + |r\\rangle\\langle g|$.\n", + "\n", + "The interaction Hamiltonian dictates that there is an additional energy of $C_6/R^6$ for being in the $|rr\\rangle$ state - that is to say, the energy of the $|rr\\rangle$ state is shifted by this amount.\n", + "\n", + "When we try to drive the transition to the $|rr\\rangle$ state, the excitation does not occur when $\\hbar\\Omega \\ll C_6/R^6$, i.e the energy of the drive is not sufficient to overcome the extra cost of having the system in in the $|rr\\rangle$ state - this is the so-called *Rydberg blockade*. Instead, the system is excited to $(|gr\\rangle + |rg\\rangle)/\\sqrt{2}$ (notably, an entangled state) with effective Rabi frequency $\\sqrt{2}\\Omega$. \n", + "\n", + "From the Rydberg blockade condition, we define the **Rydberg blockade radius** as\n", + "\n", + "$$R_b = \\left(\\frac{C_6}{\\hbar\\Omega}\\right)^{(1/6)}$$\n", + "\n", + "For any pair of atoms $i$ and $j$ in a system under a global resonant drive:\n", + "- When $R_{ij} \\ll R_b$, the excitation to $|rr\\rangle$ is suppressed.\n", + "- When $R_{ij} \\gg R_b$, the excitation to $|rr\\rangle$ occurs.\n", + "\n", + "
\n", + " \"Rydberg\n", + "
The Rydberg blockade: The energy of the $|rr\\rangle$ state (blue line) increases signficantly for atoms less than a blockade radius ($R_\\text{Blockade}$ in this picture, $R_b$ elsewhere this document) away. As such, the transition to $|rr\\rangle$ is suppressed when $R_{ij} \\ll R_b$. Source: Quantum 6, 629 (2022)\n", + "
\n", + "
\n", + "\n", + "
\n", + "\n", + "**Important notes**:\n", + "\n", + "- The Rydberg blockade radius is only a useful approximation to reason about whether two atoms interact significantly; it *should not* be interpreted as a discrete threshold beyond which there are no interactions.\n", + "- In fact, the approximation is least adequate for values of $R_{ij} \\approx R_b$, so placing atoms at distances close to $R_b$ should be done extra carefully.\n", + "- Furthermore, $R_b$ depends on the Rabi frequency $\\Omega$; as such, **fixing** $R_b$ **also determines** $\\Omega$ and vice-versa. \n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "935fb6c0", + "metadata": {}, + "source": [ + "### Estimating the Rydberg blockade radius\n", + "\n", + "The `Device` class includes methods to calculate the Rydberg blockade radius for a given value of Rabi frequency and vice-versa." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "164cde0c", + "metadata": {}, + "outputs": [], + "source": [ + "import pulser\n", + "\n", + "# Blockade radius from Rabi frequency\n", + "omega = 1 # rad/μs\n", + "rb = pulser.AnalogDevice.rydberg_blockade_radius(omega) # μm\n", + "print(f\"Rydberg blockade radius for Ω={omega} rad/μs: {rb} μm\")\n", + "\n", + "# Rabi frequency from Blockade radius\n", + "rb = 8 # μm\n", + "omega = pulser.AnalogDevice.rabi_from_blockade(rb) # rad/μs\n", + "print(f\"Rydberg blockade radius for Ω={omega} rad/μs: {rb} μm\")" + ] + }, + { + "cell_type": "markdown", + "id": "4c39956e", + "metadata": {}, + "source": [ + "### Visualising interactions\n", + "\n", + "The `Register.draw()` method includes options to plot the Rydberg blockade radius and identifiy interacting atoms. By specifying a value for `blockade_radius`,\n", + "- `draw_half_radius=True` draws a circle with **half** the Rydberg blockade radius on each atom; when two circles overlap, the atoms are within a blockade radius of each other.\n", + "- `draw_graph=True` draws connections between the atoms within a blockade radius of each other." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d1aa660", + "metadata": {}, + "outputs": [], + "source": [ + "from pulser import Register\n", + "\n", + "# 4x3 triangular lattice with 6μm spacing\n", + "tri_reg = Register.triangular_lattice(\n", + " rows=4, atoms_per_row=3, spacing=6.0, prefix=\"q\"\n", + ")\n", + "# Draw the interactions for Rb=7 μm\n", + "tri_reg.draw(\n", + " blockade_radius=7, # μm\n", + " draw_half_radius=True, # Draws circles with radius Rb/2\n", + " draw_graph=True, # Draws edges between interacting atoms\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ce1defb6", + "metadata": {}, + "source": [ + "## Tips for `Register` design" + ] + }, + { + "cell_type": "markdown", + "id": "12f85b91", + "metadata": {}, + "source": [ + "Choosing the best position for the atoms in a `Register` is generally a hard problem and depends heavily on the application. In this section, we provide some strategies that, while far from exhaustive, may help in the `Register` creation process in specfic cases." + ] + }, + { + "cell_type": "markdown", + "id": "40247508", + "metadata": {}, + "source": [ + "### Think of the full Hamiltonian\n", + "\n", + "When using a neutral-atom QPU to simulate a quantum many-body system, it is important to remember that the interaction Hamiltonian is but one part of the full Hamiltonian. In particular, the strength of the interaction terms must always be considered in relation to the driving Hamiltonian terms (i.e. $\\Omega$ and $\\delta$) - in fact, the interdependence between $R_b$ and $\\Omega$ is itself a prime example as to why these terms should not be designed in isolation.\n", + "\n", + "Take the example of [AFM state preparation](tutorials/creating.nblink#Adiabatic-preparation-of-an-Anti-Ferromagnetic-State), where the interaction strength must be balanced with the appropriate value of $\\delta>0$; without taking the full Hamiltonian into account, we could end up with:\n", + "- $\\delta$ too low, which would not promote atoms to the $|r\\rangle$ state, or\n", + "- $\\delta$ too high, which would make all atoms go to the $|r\\rangle$ state, regardless of their nearest neighbours being also in $|r\\rangle$.\n", + "\n", + "In these cases, it is only by first considering the full Hamiltonian that we are able to correctly design the register." + ] + }, + { + "cell_type": "markdown", + "id": "c05632f6", + "metadata": {}, + "source": [ + "### Encode a cost function\n", + "\n", + "Akin to a penalty term in a cost function, the interaction Hamiltonian makes some quantum states energetically less favourable. By appropriately adjusting the distances between atoms, the penalty of specific candidate solutions can sometimes be replicated in the interaction Hamiltonian.\n", + "\n", + "Examples where this approach is useful include:\n", + "- some instances of [QUBO](https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization) problems,\n", + "- other optimization problems where the ground-state of the Hamiltonian encodes a minimizer of the cost function.\n" + ] + }, + { + "cell_type": "markdown", + "id": "bc0b100b", + "metadata": {}, + "source": [ + "### Start from a connectivity graph\n", + "\n", + "In the formulation of some problems, the exact value of the interaction strength between two atoms is not relevant; instead, all that matters is the presence or absence of interactions. As such, we can express these interactions through a so-called *connectivity graph*, where a node is an atom and an edge connects interacting atoms (as drawn in [this section](#Visualising-interactions)).\n", + "\n", + "In these cases, the [Rydberg blockade radius](#The-Rydberg-Blockade) provides a useful approximation by allowing us to place interacting atoms well within a blockade radius of each other and non-interacting atoms well outside it. Turning a connectivity graph into a `Register` is particularly straigthfoward when the connectivity graph can be represented as a [Unit-Disk graph](https://en.wikipedia.org/wiki/Unit_disk_graph). \n", + "\n", + "Examples where this approach is useful include:\n", + "- finding the Maximum Independent Set of a Unit-Disk graph,\n", + "- placing atoms for execution of multi-qubit gates." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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 +} diff --git a/docs/source/tutorials/1D_crystals.nblink b/docs/source/tutorials/1D_crystals.nblink deleted file mode 100644 index 40da06e50..000000000 --- a/docs/source/tutorials/1D_crystals.nblink +++ /dev/null @@ -1,3 +0,0 @@ -{ - "path": "../../../tutorials/quantum_simulation/Building 1D Rydberg Crystals.ipynb" -} diff --git a/docs/source/tutorials/cz_gate.nblink b/docs/source/tutorials/cz_gate.nblink deleted file mode 100644 index 12057d48b..000000000 --- a/docs/source/tutorials/cz_gate.nblink +++ /dev/null @@ -1,3 +0,0 @@ -{ - "path": "../../../tutorials/applications/Control-Z Gate Sequence.ipynb" -} diff --git a/docs/source/tutorials/mw_engineering.nblink b/docs/source/tutorials/mw_engineering.nblink deleted file mode 100644 index 9b5caebdd..000000000 --- a/docs/source/tutorials/mw_engineering.nblink +++ /dev/null @@ -1,3 +0,0 @@ -{ - "path": "../../../tutorials/quantum_simulation/Microwave-engineering of programmable XXZ Hamiltonians in arrays of Rydberg atoms.ipynb" -} diff --git a/docs/source/tutorials/shadow_est.nblink b/docs/source/tutorials/shadow_est.nblink deleted file mode 100644 index 401a03802..000000000 --- a/docs/source/tutorials/shadow_est.nblink +++ /dev/null @@ -1,3 +0,0 @@ -{ - "path": "../../../tutorials/quantum_simulation/Shadow estimation for VQS.ipynb" -} diff --git a/pulser-core/pulser/register/register.py b/pulser-core/pulser/register/register.py index 0f0be2fd8..17df945ee 100644 --- a/pulser-core/pulser/register/register.py +++ b/pulser-core/pulser/register/register.py @@ -70,7 +70,7 @@ def square( spacing: float | pm.TensorLike = 4.0, prefix: Optional[str] = None, ) -> Register: - """Initializes the register with the qubits in a square array. + """Creates the register with the qubits in a square array. Args: side: Side of the square in number of qubits. @@ -173,7 +173,7 @@ def triangular_lattice( spacing: float | pm.TensorLike = 4.0, prefix: Optional[str] = None, ) -> Register: - """Initializes the register with the qubits in a triangular lattice. + """Creates the register with the qubits in a triangular lattice. Initializes the qubits in a triangular lattice pattern, more specifically a triangular lattice with horizontal rows, meaning the @@ -226,7 +226,7 @@ def hexagon( spacing: float | pm.TensorLike = 4.0, prefix: Optional[str] = None, ) -> Register: - """Initializes the register with the qubits in a hexagonal layout. + """Creates the register with the qubits in a hexagonal layout. Args: layers: Number of layers around a central atom. diff --git a/tutorials/quantum_simulation/Building 1D Rydberg Crystals.ipynb b/tutorials/retired/Building 1D Rydberg Crystals.ipynb similarity index 100% rename from tutorials/quantum_simulation/Building 1D Rydberg Crystals.ipynb rename to tutorials/retired/Building 1D Rydberg Crystals.ipynb diff --git a/tutorials/applications/Control-Z Gate Sequence.ipynb b/tutorials/retired/Control-Z Gate Sequence.ipynb similarity index 100% rename from tutorials/applications/Control-Z Gate Sequence.ipynb rename to tutorials/retired/Control-Z Gate Sequence.ipynb diff --git a/tutorials/quantum_simulation/Microwave-engineering of programmable XXZ Hamiltonians in arrays of Rydberg atoms.ipynb b/tutorials/retired/Microwave-engineering of programmable XXZ Hamiltonians in arrays of Rydberg atoms.ipynb similarity index 100% rename from tutorials/quantum_simulation/Microwave-engineering of programmable XXZ Hamiltonians in arrays of Rydberg atoms.ipynb rename to tutorials/retired/Microwave-engineering of programmable XXZ Hamiltonians in arrays of Rydberg atoms.ipynb diff --git a/tutorials/retired/README.md b/tutorials/retired/README.md new file mode 100644 index 000000000..bd0635493 --- /dev/null +++ b/tutorials/retired/README.md @@ -0,0 +1,3 @@ +# Retired Pulser Tutorials + +This folder gathers old Pulser tutorials that have since been retired. They are not maintained and compatibility with the current Pulser release is not ensured. diff --git a/tutorials/quantum_simulation/Shadow estimation for VQS.ipynb b/tutorials/retired/Shadow estimation for VQS.ipynb similarity index 100% rename from tutorials/quantum_simulation/Shadow estimation for VQS.ipynb rename to tutorials/retired/Shadow estimation for VQS.ipynb diff --git a/tutorials/retired/intro_rydberg_blockade.ipynb b/tutorials/retired/intro_rydberg_blockade.ipynb new file mode 100644 index 000000000..35cef0446 --- /dev/null +++ b/tutorials/retired/intro_rydberg_blockade.ipynb @@ -0,0 +1,243 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quickstart: The Rydberg Blockade" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following walkthrough highlights some of Pulser's core features and uses them to display a crucial physical effect for neutral atom devices: the **Rydberg blockade**. Bear in mind that it is not meant to be a comprehensive step-by-step guide on how to use Pulser, but rather a showcase of Pulser in action. \n", + "\n", + "For a more detailed introduction to Pulser, check the tutorials on [Pulse Sequence Creation](tutorials/creating.nblink) and [Simulation of Sequences](tutorials/simulating.nblink). To better understand neutral atom devices and how they serve as quantum computers and simulators, check the pages in [Quantum Computing with Neutral Atoms](review.rst)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pulser's main features" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pulser\n", + "from pulser_simulation import QutipEmulator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With ``pulser``, it is easy to define a ``Register`` consisting of any arrangement of atoms in a quantum processor. For example, we can generate a register with hexagonal shape:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "layers = 3\n", + "reg = pulser.Register.hexagon(layers, prefix=\"q\")\n", + "reg.draw(with_labels=False)" + ] + }, + { + "attachments": { + "download%20%282%29.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, we can place the atoms in arbitrary positions by specifying the positions of each one. As an exotic example, here is a picture of the Gioconda as a register of neutral atoms made using Pulser:\n", + "\n", + "![download%20%282%29.png](attachment:download%20%282%29.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is also simple to create and design a ``Pulse`` that will act on the atom array:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "duration = 1000 # Typical: ~1 µsec\n", + "pulse = pulser.Pulse(\n", + " amplitude=pulser.BlackmanWaveform(duration, np.pi),\n", + " detuning=pulser.RampWaveform(duration, -5.0, 10.0),\n", + " phase=0,\n", + ")\n", + "pulse.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each pulse acts on a set of atoms at a certain moment of time. The entire ``Sequence`` is stored by Pulser and can then be either simulated or sent to a real device. Below is the example of a sequence sending the same $\\pi$-pulse to two atoms, sequentially, using the same channel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "reg = pulser.Register.rectangle(1, 2, spacing=8, prefix=\"atom\")\n", + "reg.draw()\n", + "\n", + "pi_pulse = pulser.Pulse.ConstantDetuning(\n", + " pulser.BlackmanWaveform(duration, np.pi), 0.0, 0.0\n", + ")\n", + "\n", + "seq = pulser.Sequence(reg, pulser.DigitalAnalogDevice)\n", + "\n", + "seq.declare_channel(\"ryd\", \"rydberg_local\", \"atom0\")\n", + "\n", + "seq.add(pi_pulse, \"ryd\")\n", + "seq.target(\"atom1\", \"ryd\")\n", + "seq.add(pi_pulse, \"ryd\")\n", + "\n", + "seq.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Probing the Rydberg Blockade Mechanism" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rydberg atoms are a prominent architecture for exploring condensed matter physics and quantum information processing. For example, one can use Pulser to write a sequence of succesive $\\pi$-pulses on a two atom system, each one coupling the atom to its excited Rydberg state. This will allow us to study the *Rydberg Blockade* effect, using the dedicated ``pulser_simulation`` library:\n", + "\n", + "The presence of the van der Waals interaction when both atoms are in the Rydberg state, prevents the collective ground state $|gg\\rangle$ to couple to $|rr\\rangle$, which is shifted out of resonance. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Hamiltonian for the two-atom system can be written as:\n", + "\n", + "$$H = \\frac{\\hbar \\Omega_1(t)}{2} \\sigma_1^x + \\frac{\\hbar \\Omega_2(t)}{2} \\sigma_2^x + U n_1n_2 $$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We shall explore this blockade by changing the interatomic distance $R$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = []\n", + "distances = np.linspace(6.5, 14, 7)\n", + "\n", + "r = [1, 0] # |r>\n", + "rr = np.kron(r, r) # |rr>\n", + "occup = [np.outer(rr, np.conj(rr))] # |rr> 5}\n", + "\n", + "plt.figure(figsize=(15, 4))\n", + "plt.xticks(rotation=90, fontsize=14)\n", + "plt.title(\"Most frequent observations\")\n", + "plt.bar(large_counts.keys(), large_counts.values())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the most frequent bitstrings correspond to the antiferromagnetic order states." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also compute the expectation values of operators for the states in the evolution, using the `expect()` method, which takes a list of operators (in this case, the local magnetization acting on the $j$-th spin):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def magnetization(j, total_sites):\n", + " prod = [qutip.qeye(2) for _ in range(total_sites)]\n", + " prod[j] = qutip.sigmaz()\n", + " return qutip.tensor(prod)\n", + "\n", + "\n", + "magn_list = [magnetization(j, L) for j in range(L)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "expect_magnetization = results.expect(magn_list)\n", + "for data in expect_magnetization:\n", + " plt.plot(sim.evaluation_times, data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the local magnetization on *each* atom goes in the same way from $-1$ (which corresponds to the ground state) to $0$. This is expected since as we saw above, the state after the evolution has antiferromagnetic-order, so at each site, there is a compensation of magnetization. The parity (even) and the boundary conditions (periodic) allow for two lowest-energy states, whose superposition is similar to that of the perfectly antiferromagnetic state: $\\Big(|grgr\\cdots \\rangle + |rgrg\\cdots \\rangle\\Big)/\\sqrt{2}$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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": 4 +}