diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000..cda0ced --- /dev/null +++ b/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,29 @@ +* **I'm submitting a ...** + - [ ] bug report + - [ ] feature request + + +* **What is the current behavior?** + + + +* **If the current behavior is a bug, please provide the steps to reproduce and if possible a minimal demo of the problem** + + + +* **What is the expected behavior?** + + + +* **What is the motivation / use case for changing the behavior?** + + + +* **Please tell us about your environment:** + + - Version: + - Platform: + - Subsystem: + + +* **Other information** (e.g. detailed explanation, stacktraces, related issues, suggestions how to fix, links for us to have context, eg. stackoverflow, gitter, etc) \ No newline at end of file diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..4aa196e --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,23 @@ +* **Please check if the PR fulfills these requirements** +- [ ] The commit message follows our guidelines +- [ ] Tests for the changes have been added (for bug fixes / features) +- [ ] Docs have been added / updated (for bug fixes / features) + + +* **What kind of change does this PR introduce?** (Bug fix, feature, docs update, ...) + + + +* **What is the current behavior?** (You can also link to an open issue here) + + + +* **What is the new behavior (if this is a feature change)?** + + + +* **Does this PR introduce a breaking change?** (What changes might users need to make in their application due to this PR?) + + + +* **Other information**: diff --git a/examples/quantum_scars.ipynb b/examples/quantum_scars.ipynb new file mode 100644 index 0000000..0e62c8e --- /dev/null +++ b/examples/quantum_scars.ipynb @@ -0,0 +1,241 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quantum Many-Body Scars and Non-Ergodic Dynamics\n", + "\n", + "See: \n", + "Turner, C.J., Michailidis, A.A., Abanin, D.A. et al. Weak ergodicity breaking from quantum many-body scars. Nature Phys 14, 745–749 (2018). https://doi.org/10.1038/s41567-018-0137-5\n", + "[https://www.nature.com/articles/s41567-018-0137-5](https://www.nature.com/articles/s41567-018-0137-5)\n", + "\n", + "This notebook will reconstruct the behaviour demonstrated in Fig. 2.\n", + "\n", + "Quantum many-body scars are a phenomenon where a small set of atypical eigenstates within an otherwise thermalizing system lead to long-lived oscillations in dynamics, defying conventional ergodicity. Unlike many-body localization, which relies on disorder to prevent thermalization, these scars emerge in translation-invariant systems and cause the system to retain memory of its initial state for unexpectedly long times.\n", + "\n", + "This notebook implements a key early result in the study of quantum many-body scars, where a specific interacting Hamiltonian exhibits long-time oscillations when initialized in a period-2 charge density wave state. The recurrence of local observables and entanglement entropy oscillations suggest the presence of special eigenstates embedded in the spectrum." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Hamiltonian describes an interacting quantum system with constrained dynamics. It is given by: \n", + "\n", + "$$\n", + "H = \\sum_{i} P^z_{i} X_{i+1} P^z_{i+2}\n", + "$$\n", + "\n", + "where: \n", + "- $X_{i}$ is the Pauli-X operator acting on site $i$, which flips the state of a qubit. \n", + "- $P^z_{i} = \\frac{1 + Z_i}{2}$ is a projector that enforces a constraint on site $i$, involving the Pauli-Z operator (note a sign difference from the paper due to different basis state conventions)\n", + "\n", + "This Hamiltonian describes a system where spins (qubits) interact in a constrained way, meaning that spin flips (\\(X\\) terms) only occur when specific neighboring conditions are met (enforced by the $P^z$ projectors). \n", + "\n", + "## Initial States and the Scarred Dynamics \n", + "\n", + "A key observation in the study of quantum many-body scars is that certain initial states exhibit long-time oscillations instead of thermalizing. One such state is the **period-2 charge density wave** (CDW), defined as: \n", + "\n", + "$$\n", + "\\left| \\mathbb{Z}_2 \\right\\rangle = \\left| 101010\\cdots \\right\\rangle\n", + "$$\n", + "\n", + "where \"1\" represents an excited atom (spin-up) and \"0\" represents the ground state (spin-down). When evolving this state under the Hamiltonian, we observe periodic revivals in local observables and entanglement entropy, instead of the system fully thermalizing as expected in most quantum chaotic systems. \n", + "\n", + "## Why This Happens: Many-Body Scars \n", + "\n", + "Instead of having all eigenstates behave chaotically (ergodically), this system contains **special eigenstates** that are evenly spaced in energy and have an anomalously low entanglement entropy. These states lead to **non-ergodic** dynamics where the system oscillates between specific configurations instead of reaching thermal equilibrium. \n", + "\n", + "## Implementation in Code \n", + "\n", + "- The function `site(i, L)` constructs the local interaction term $P^z_{i} X_{i+1} P^z_{i+2}$. \n", + "- The term `zk_gate` initializes the system in a charge density wave state. \n", + "- The Hamiltonian `hamiltonian` is built as a sum over all sites. \n", + "- The circuit then simulates time evolution using quantum gates based on the Hamiltonian. \n", + "\n", + "This implementation numerically reproduces the long-lived oscillations observed in quantum many-body scars." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import functools\n", + "import itertools\n", + "import operator\n", + "from rich.pretty import pprint\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "from oqd_core.interface.analog.operator import PauliI, PauliX, PauliZ\n", + "from oqd_core.interface.analog.operation import AnalogCircuit, AnalogGate\n", + "from oqd_core.backend.metric import Expectation, EntanglementEntropyVN\n", + "from oqd_core.backend.task import Task, TaskArgsAnalog\n", + "from oqd_compiler_infrastructure.rule import PrettyPrint\n", + "from oqd_compiler_infrastructure.walk import Post\n", + "from oqd_core.compiler.analog.utils import PrintOperator\n", + "from oqd_core.compiler.analog.passes.canonicalize import analog_operator_canonicalization \n", + "\n", + "from oqd_analog_emulator.qutip_backend import QutipBackend" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def sum(args):\n", + " return functools.reduce(operator.add, args)\n", + "\n", + "def prod(args):\n", + " return functools.reduce(operator.mul, args)\n", + "\n", + "def tensor(args):\n", + " return functools.reduce(operator.matmul, args)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def site(i: int, L: int):\n", + " term = [PauliI() for j in range(L)]\n", + " term[i] = (PauliI() + PauliZ()) * 0.5\n", + " term[(i + 1) % L] = PauliX()\n", + " term[(i + 2) % L] = (PauliI() + PauliZ()) * 0.5\n", + " return tensor(term)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Zk gate: PauliX() @ PauliI() @ PauliX() @ PauliI() @ PauliX() @ PauliI() @ PauliX() @ PauliI() @ PauliX() @ PauliI() @ PauliX() @ PauliI()\n", + "Hamlitonian: ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() + PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() + PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() + PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() + PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() + PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() + PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() + PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() + PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() + PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() @ ((0.5) * (PauliI() + PauliZ())) + ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ())) @ PauliX() + PauliX() @ ((0.5) * (PauliI() + PauliZ())) @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ PauliI() @ ((0.5) * (PauliI() + PauliZ()))\n" + ] + } + ], + "source": [ + "n = 12\n", + "k = 2\n", + "zk_gate = sum([tensor([PauliX() if j%k == 0 else PauliI() for j in range(n)])])\n", + "\n", + "hamiltonian = sum([site(i, n) for i in range(n)])\n", + "fstring = Post(PrintOperator())\n", + "print(f\"Zk gate: {fstring(zk_gate)}\\nHamlitonian: {fstring(hamiltonian)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "circuit = AnalogCircuit()\n", + "circuit.evolve(duration=np.pi/2, gate=AnalogGate(hamiltonian=zk_gate))\n", + "circuit.evolve(duration=10, gate=AnalogGate(hamiltonian=hamiltonian))\n", + "circuit.measure()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "args = TaskArgsAnalog(\n", + " n_shots=1000,\n", + " fock_cutoff=1,\n", + " metrics={\n", + " f\"Z_{i}\": Expectation(operator=tensor([PauliZ() if j in (i, (i+1)%n) else PauliI() for j in range(n)]))\n", + " for i in range(n)\n", + " } | {\"S\": EntanglementEntropyVN(qreg=list(range(n//2)))},\n", + " dt=1e-2,\n", + ")\n", + "task = Task(program=circuit, args=args)\n", + "\n", + "backend = QutipBackend()\n", + "results = backend.run(task=task)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(ncols=1, nrows=3, sharex=True, figsize=[6, 3])\n", + "colors = sns.color_palette(palette=\"muted\", n_colors=max([20, n]))\n", + "\n", + "axs[0].plot(results.times, results.metrics['S'], label=f\"$S$\", color=colors[0])\n", + "axs[1].plot(results.times, np.diff(results.metrics['S'], prepend=0.0), label=f\"$S$\", color=colors[1])\n", + "\n", + "expectations = {metric: value for (metric, value) in results.metrics.items() if 'Z' in metric}\n", + "for k, (name, metric) in enumerate(expectations.items()):\n", + " axs[2].plot(results.times, metric, label=f\"$\\\\langle {name} \\\\rangle$\", color=colors[k])\n", + "\n", + "for ax in axs:\n", + " ax.axvspan(0, np.pi/2, color=\"gray\", alpha=0.4)\n", + "\n", + "axs[0].set(ylabel=r\"$S$\")\n", + "axs[1].set(ylabel=r\"$\\Delta S$\")\n", + "axs[2].set(ylabel=r\"$\\langle Z_i Z_{i+1} \\rangle$\")\n", + "axs[-1].set(xlabel=\"Time\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/mkdocs.yaml b/mkdocs.yaml index 1b0add3..ca721f0 100644 --- a/mkdocs.yaml +++ b/mkdocs.yaml @@ -37,6 +37,7 @@ nav: - Sigmoid time-dependence: examples/adiabatic_sigmoid.ipynb - Ising model: examples/ising_model.ipynb - QAOA: examples/qaoa.ipynb + - Quantum scars: examples/quantum_scars.ipynb - Core: "!include ./oqd-core/mkdocs.yaml" - Emulators: diff --git a/pyproject.toml b/pyproject.toml index 81ddbe6..08a80a2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,10 +38,10 @@ classifiers = [ dependencies = [ "matplotlib", "seaborn", - "oqd-compiler-infrastructure", - "oqd-core", - "oqd-analog-emulator", - "oqd-cloud", + "oqd-compiler-infrastructure@git+https://github.com/openquantumdesign/oqd-compiler-infrastructure", + "oqd-core @ git+https://github.com/openquantumdesign/oqd-core", + "oqd-analog-emulator @ git+https://github.com/openquantumdesign/oqd-analog-emulator", + "oqd-cloud @ git+https://github.com/openquantumdesign/oqd-cloud", ] [project.optional-dependencies]