Clifford_RZ_RCS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "composed-midwest",
   "metadata": {},
   "source": [
    "# Qrack Clifford+RZ and Mitiq for High-Width RCS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "social-scott",
   "metadata": {},
   "source": [
    "You need the `pyqrack` package to run this notebook. [`vm6502q/pyqrack`](https://github.com/vm6502q/pyqrack) is a pure Python wrapper on the [`vm6502q/qrack`](https://github.com/vm6502q/qrack) quantum computer simulation framework core library. The preferred method of installation is from source code, at those GitHub repositories, but a package with default build precompiled binaries is available on [pypi](https://pypi.org/project/pyqrack/0.2.0/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a647098-dd6d-4ee0-806f-abc2f5cd37ab",
   "metadata": {},
   "source": [
    "In the example below, we use Qiskit's `QuantumCircuit`, which makes this easier to combine with Mitiq, for further development."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e342bcef",
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 36\n",
    "depth = 6\n",
    "max_magic = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cubic-thousand",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-21 11:47:21.864025: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "# For example, if your Jupyter installation uses pip:\n",
    "# import sys\n",
    "# !{sys.executable} -m pip install pyqrack\n",
    "\n",
    "import os\n",
    "import collections\n",
    "import math\n",
    "import multiprocessing\n",
    "import numpy as np\n",
    "import time\n",
    "import random\n",
    "\n",
    "from pyqrack import QrackSimulator, Pauli\n",
    "from qiskit.circuit.quantumcircuit import QuantumCircuit\n",
    "\n",
    "# from mitiq import zne\n",
    "# from mitiq.zne.scaling.folding import fold_global\n",
    "# from mitiq.zne.inference import RichardsonFactory\n",
    "\n",
    "# Change these according to your OpenCL devices and system specifications:\n",
    "os.environ['QRACK_MAX_ALLOC_MB']='15872'\n",
    "os.environ['QRACK_MAX_PAGE_QB']='-1'\n",
    "os.environ['QRACK_MAX_PAGING_QB']='-1'\n",
    "os.environ['QRACK_MAX_CPU_QB']='-1'\n",
    "# os.environ['QRACK_QUNITMULTI_DEVICES']='1'\n",
    "# os.environ['QRACK_QPAGER_DEVICES']='1'\n",
    "# os.environ['QRACK_QTENSORNETWORK_THRESHOLD_QB']='-1'\n",
    "os.environ['QRACK_NONCLIFFORD_ROUNDING_THRESHOLD']='2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "59c4e106-4dcb-4c60-938f-a93da5f4a487",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cx(circ, q1, q2):\n",
    "    circ.cx(q1, q2)\n",
    "\n",
    "def cy(circ, q1, q2):\n",
    "    circ.cy(q1, q2)\n",
    "\n",
    "def cz(circ, q1, q2):\n",
    "    circ.cz(q1, q2)\n",
    "\n",
    "def acx(circ, q1, q2):\n",
    "    circ.x(q1)\n",
    "    circ.cx(q1, q2)\n",
    "    circ.x(q1)\n",
    "\n",
    "def acy(circ, q1, q2):\n",
    "    circ.x(q1)\n",
    "    circ.cy(q1, q2)\n",
    "\n",
    "def acz(circ, q1, q2):\n",
    "    circ.x(q1)\n",
    "    circ.cz(q1, q2)\n",
    "    circ.x(q1)\n",
    "\n",
    "def swap(circ, q1, q2):\n",
    "    circ.swap(q1, q2)\n",
    "\n",
    "def nswap(circ, q1, q2):\n",
    "    circ.cz(q1, q2)\n",
    "    circ.swap(q1, q2)\n",
    "    circ.cz(q1, q2)\n",
    "\n",
    "def pswap(circ, q1, q2):\n",
    "    circ.cz(q1, q2)\n",
    "    circ.swap(q1, q2)   \n",
    "\n",
    "def mswap(circ, q1, q2):\n",
    "    circ.swap(q1, q2)\n",
    "    circ.cz(q1, q2)\n",
    "\n",
    "def iswap(circ, q1, q2):\n",
    "    circ.swap(q1, q2)\n",
    "    circ.cz(q1, q2)\n",
    "    circ.s(q1)\n",
    "    circ.s(q2)\n",
    "\n",
    "def iiswap(circ, q1, q2):\n",
    "    circ.sdg(q2)\n",
    "    circ.sdg(q1)\n",
    "    circ.cz(q1, q2)\n",
    "    circ.swap(q1, q2)\n",
    "\n",
    "def random_circuit(width, depth, magic):\n",
    "    circuit = QuantumCircuit(width)\n",
    "\n",
    "    magic_fraction = (3 * (width - 1) * depth / max_magic) if (width == 54) else (3 * width * depth / max_magic)\n",
    "    \n",
    "    # Nearest-neighbor couplers:\n",
    "    gateSequence = [ 0, 3, 2, 1, 2, 1, 0, 3 ]\n",
    "    two_bit_gates = swap, pswap, mswap, nswap, iswap, iiswap, cx, cy, cz, acx, acy, acz\n",
    "\n",
    "    col_len = math.floor(math.sqrt(width))\n",
    "    while (((width // col_len) * col_len) != width):\n",
    "        col_len -= 1\n",
    "    row_len = width // col_len\n",
    "    dead_qubit = 3\n",
    "\n",
    "    for i in range(depth):\n",
    "        # Single bit gates\n",
    "        for j in range(width):\n",
    "            if (width == 54) and (j == dead_qubit):\n",
    "                continue\n",
    "\n",
    "            for _ in range(3):\n",
    "                # We're trying to cover 3 Pauli axes\n",
    "                # with Euler angle axes x-z-x. \n",
    "                circuit.h(j)\n",
    "\n",
    "                # We can trace out a quarter rotations around the Bloch sphere with stabilizer.\n",
    "                rnd = random.randint(0, 3)\n",
    "                if rnd & 1:\n",
    "                    circuit.s(j)\n",
    "                if rnd & 2:\n",
    "                    circuit.z(j)\n",
    "\n",
    "                # For each axis, there is a chance of \"magic.\"\n",
    "                if (magic > 0) and ((magic_fraction * random.random()) < 1):\n",
    "                    angle = random.uniform(0, math.pi / 2)\n",
    "                    circuit.rz(angle, j)\n",
    "                    magic -= 1\n",
    "\n",
    "        # Nearest-neighbor couplers:\n",
    "        ############################\n",
    "        gate = gateSequence.pop(0)\n",
    "        gateSequence.append(gate)\n",
    "        for row in range(1, row_len, 2):\n",
    "            for col in range(col_len):\n",
    "                temp_row = row\n",
    "                temp_col = col\n",
    "                temp_row = temp_row + (1 if (gate & 2) else -1);\n",
    "                temp_col = temp_col + (1 if (gate & 1) else 0)\n",
    "\n",
    "                if (temp_row < 0) or (temp_col < 0) or (temp_row >= row_len) or (temp_col >= row_len):\n",
    "                    continue\n",
    "\n",
    "                b1 = row * row_len + col\n",
    "                b2 = temp_row * row_len + temp_col\n",
    "\n",
    "                if (b1 >= width) or (b2 >= width):\n",
    "                    continue\n",
    "\n",
    "                g = random.choice(two_bit_gates)\n",
    "                g(circuit, b1, b2)\n",
    "    \n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c935d73-868e-4fc1-b75d-aff5f90ca566",
   "metadata": {},
   "source": [
    "Run this next cell several times to produce a noisy value, optionally tuning the width, depth, and magic settings above. (Then, we could theoretically mitigate with Mitiq.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95676cb3-ce66-4daf-a146-76be48723273",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device #0, Loaded binary from: /home/iamu/.qrack/qrack_ocl_dev_NVIDIA_GeForce_RTX_2070_Super.ir\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "from multiprocessing import Process\n",
    "\n",
    "def run_in_parallel(task):\n",
    "    running_tasks = [Process(target=task) for _ in range(os.cpu_count())]\n",
    "    for running_task in running_tasks:\n",
    "        running_task.start()\n",
    "    for running_task in running_tasks:\n",
    "        running_task.join()\n",
    "\n",
    "def run_random_circuit():\n",
    "    start = time.perf_counter()\n",
    "    circ = random_circuit(width, depth, max_magic)\n",
    "    qsim = QrackSimulator(circ.width(), isStabilizerHybrid=True, isTensorNetwork=False, isSchmidtDecompose=False)\n",
    "    qsim.run_qiskit_circuit(circ, 0)\n",
    "    # This is just to ensure that the non-Clifford buffers get flushed and rounded:\n",
    "    qsim.prob_perm(list(range(width)), [False] * width)\n",
    "\n",
    "    print(\"Fidelity: \", qsim.get_unitary_fidelity(), \", Time: \", time.perf_counter() - start, \"s\")\n",
    "\n",
    "# run_in_parallel(run_random_circuit)\n",
    "run_random_circuit()"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}