css_code_circuit.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a `CssCodeCircuit`\n",
    "\n",
    "* Let's pretend that there exists an abstract CSS subsystem code class in `qiskit_qec.codes`, of which `HHC` is an example. Let's call it `CssCode`.\n",
    "* With this, we could build a corresponding `CssCodeCircuit` class, which take an arbitrary `CssCode` and construct the corresponding `CodeCircuit`.\n",
    "* Using only information from the `CssCode`, we cannot construct a fully-fault-tolerant circuit. This would need a more thoughtful approach, thinking about hook errors, flag qubits, etc.\n",
    "* What we can do is construct naive circuits that will be fault-tolerant against phenomological noise.\n",
    "* So let's do that!\n",
    "* We can then extend `CssCodeCircuit` later, to allow user-defined gauge operator meaurement circuits, deflagging procedures, etc."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin by creating an example of the only `CssCode` we have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[9, 1, 3]] heavy-hexagon compass code\n",
       "x_gauges = [[0, 3], [1, 4], [2, 5], [3, 6], [4, 7], [5, 8]]\n",
       "z_gauges = [[0, 1], [1, 2, 4, 5], [3, 4, 6, 7], [7, 8]]\n",
       "x_stabilizers = [[0, 1, 3, 4], [2, 5], [3, 6], [4, 5, 7, 8]]\n",
       "z_stabilizers = [[0, 1, 3, 4, 6, 7], [1, 2, 4, 5, 7, 8]]\n",
       "logical_x = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
       "logical_z = [[0, 1, 2, 3, 4, 5, 6, 7, 8]]\n",
       "x_boundary = [[0], [1], [2], [6], [7], [8]]\n",
       "z_boundary = [[0], [3], [6], [2], [5], [8]]"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit_qec.codes.hhc import HHC\n",
    "code = HHC(3)\n",
    "code"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create a corresponding `CodeCircuit` class.\n",
    "\n",
    "* This constructs a circuit simply by interating through the gauge operators and applying a naive measurement process.\n",
    "* `string2nodes` combines gauge operators results into stabilizer results, and makes comparisons between measurement rounds to contruct nodes.\n",
    "* `check_nodes` and `is_cluster_neutral` cannot be defined using information from the `CssCode` alone, and so must be provided by the user.\n",
    "* Phenomological noise is defined by two keyword arguments: `p_depol` for between rounds, and `p_meas` for measurements. If given, corresponding error operators are inserted into the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.providers.aer.noise import depolarizing_error, pauli_error\n",
    "\n",
    "class CssCodeCircuit():\n",
    "    def __init__(self, code, T, basis=\"z\", round_schedule=\"zx\", p_depol=0, p_meas=0):\n",
    "\n",
    "        self.code = code\n",
    "        self.T = T\n",
    "        self.basis = basis\n",
    "        self.base = '0'\n",
    "        self.round_schedule = round_schedule\n",
    "        self.p_depol = p_depol\n",
    "        self.p_meas = p_meas\n",
    "        self._noise = p_depol > 0 or p_meas > 0\n",
    "\n",
    "        self._depol_error = depolarizing_error(p_depol, 1)\n",
    "        self._meas_error = pauli_error([('X', p_meas), ('I', 1 - p_meas)])\n",
    "\n",
    "        self.circuit = {}\n",
    "        for state in ['0', '1']:\n",
    "            qc = QuantumCircuit()\n",
    "            qregs = []\n",
    "            qregs.append(QuantumRegister(code.n, name='code qubits'))\n",
    "            qregs.append(QuantumRegister(len(code.z_gauges), name='z auxs'))\n",
    "            qregs.append(QuantumRegister(len(code.x_gauges), name='x auxs'))\n",
    "            for qreg in qregs:\n",
    "                qc.add_register(qreg)\n",
    "            # prepare initial state\n",
    "            if state == '1':\n",
    "                if basis == 'z':\n",
    "                    qc.x(code.logical_x[0])\n",
    "                else:\n",
    "                    qc.x(code.logical_z[0])\n",
    "            if basis == 'x':\n",
    "                qc.h(qregs[0])\n",
    "            # peform syndrome measurements\n",
    "            for t in range(T):\n",
    "                if self._noise:\n",
    "                    for q in qregs[0]:\n",
    "                        qc.append(self._depol_error, [q])\n",
    "                # gauge measurements\n",
    "                if round_schedule == \"zx\":\n",
    "                    self._z_gauge_measurements(qc, t)\n",
    "                    self._x_gauge_measurements(qc, t)\n",
    "                elif round_schedule == \"xz\":\n",
    "                    self._x_gauge_measurements(qc, t)\n",
    "                    self._z_gauge_measurements(qc, t)\n",
    "                else:\n",
    "                    print('Round schedule '+round_schedule+' not supported.')\n",
    "            # final readout\n",
    "            creg = ClassicalRegister(code.n, name='final_readout')\n",
    "            qc.add_register(creg)\n",
    "            if basis == 'x':\n",
    "                qc.h(qregs[0])\n",
    "            if self._noise:\n",
    "                for q in qregs[0]:\n",
    "                    qc.append(self._meas_error, [q])\n",
    "            qc.measure(qregs[0], creg)\n",
    "            self.circuit[state] = qc\n",
    "\n",
    "        self._gauges4stabilizers = []\n",
    "        self._stabilizers = [code.x_stabilizers, code.z_stabilizers]\n",
    "        self._gauges = [code.x_gauges, code.z_gauges]\n",
    "        for j in range(2):\n",
    "            self._gauges4stabilizers.append([])\n",
    "            for stabilizer in self._stabilizers[j]:\n",
    "                gauges = []\n",
    "                for g, gauge in enumerate(self._gauges[j]):\n",
    "                    if set(stabilizer).intersection(set(gauge)) == set(gauge):\n",
    "                        gauges.append(g)\n",
    "                self._gauges4stabilizers[j].append(gauges)\n",
    "\n",
    "    def _z_gauge_measurements(self, qc, t):\n",
    "        creg = ClassicalRegister(len(self.code.z_gauges), name='round_'+str(t)+'_z_bits')\n",
    "        qc.add_register(creg)\n",
    "        for g, z_gauge in enumerate(self.code.z_gauges):\n",
    "            for q in z_gauge:\n",
    "                qc.cx(qc.qregs[0][q], qc.qregs[1][g])\n",
    "            if self._noise:\n",
    "                qc.append(self._meas_error, [qc.qregs[1][g]])\n",
    "            qc.measure(qc.qregs[1][g], creg[g])\n",
    "            qc.reset(qc.qregs[1][g])\n",
    "\n",
    "    def _x_gauge_measurements(self, qc, t):\n",
    "        creg = ClassicalRegister(len(self.code.x_gauges), name='round_'+str(t)+'_x_bits')\n",
    "        qc.add_register(creg)\n",
    "        for g, x_gauge in enumerate(self.code.x_gauges):\n",
    "            for q in x_gauge:\n",
    "                qc.h(qc.qregs[0][q])\n",
    "                qc.cx(qc.qregs[0][q], qc.qregs[2][g])\n",
    "                qc.h(qc.qregs[0][q])\n",
    "            if self._noise:\n",
    "                qc.append(self._meas_error, [qc.qregs[2][g]])\n",
    "            qc.measure(qc.qregs[2][g], creg[g])\n",
    "            qc.reset(qc.qregs[2][g])\n",
    "\n",
    "    def string2nodes(self, string):\n",
    "\n",
    "        output = string.split(' ')[::-1]\n",
    "        gauge_outs = [[],[]]\n",
    "        for t in range(self.T):\n",
    "            gauge_outs[0].append(\n",
    "                [int(b) for b in output[2*t + self.round_schedule.find(\"x\")]][::-1]\n",
    "                )\n",
    "            gauge_outs[1].append(\n",
    "                [int(b) for b in output[2*t + self.round_schedule.find(\"z\")]][::-1]\n",
    "                )\n",
    "        final_outs = [int(b) for b in output[-1]]\n",
    "\n",
    "        stabilizer_outs = []\n",
    "        for j in range(2):\n",
    "            stabilizer_outs.append([])\n",
    "            for t in range(self.T):\n",
    "                round_outs = []\n",
    "                for gs in self._gauges4stabilizers[j]:\n",
    "                    out = 0\n",
    "                    for g in gs:\n",
    "                        out += gauge_outs[j][t][g]\n",
    "                    out = out % 2\n",
    "                    round_outs.append(out)\n",
    "                stabilizer_outs[j].append(round_outs)\n",
    "\n",
    "        bases = ['x','z']\n",
    "        j = bases.index(self.basis)\n",
    "        round_outs = []\n",
    "        for stabilizer in self._stabilizers[j]:\n",
    "            out = 0\n",
    "            for q in stabilizer:\n",
    "                out += final_outs[q]\n",
    "            out = out % 2\n",
    "            round_outs.append(out)\n",
    "        stabilizer_outs[j].append(round_outs)\n",
    "\n",
    "        stabilizer_changes = []\n",
    "        for j in range(2):\n",
    "            stabilizer_changes.append([])\n",
    "            for t in range(self.T + (bases[j] == self.basis)):\n",
    "                stabilizer_changes[j].append([])\n",
    "                for e in range(len(stabilizer_outs[j][t])):\n",
    "                    if t == 0 and j == bases.index(self.basis):\n",
    "                        stabilizer_changes[j][t].append(\n",
    "                            stabilizer_outs[j][t][e]\n",
    "                            )\n",
    "                    else:\n",
    "                        stabilizer_changes[j][t].append(\n",
    "                            (stabilizer_outs[j][t][e] + stabilizer_outs[j][t-1][e]) % 2\n",
    "                        )\n",
    "\n",
    "        nodes = []\n",
    "        for j in range(2):\n",
    "            for t, round_changes in enumerate(stabilizer_changes[j]):\n",
    "                for e, change in enumerate(round_changes):\n",
    "                    if change == 1:\n",
    "                        node = {\n",
    "                            'time': t,\n",
    "                            'basis': bases[j],\n",
    "                            'qubits': self._stabilizers[j][e],\n",
    "                            'element': e,\n",
    "                            'is_boundary': False\n",
    "                            }\n",
    "                        nodes.append(node)\n",
    "\n",
    "        j = bases.index(self.basis)\n",
    "        boundary = [self.code.x_boundary, self.code.z_boundary]\n",
    "        boundary_qubits = [q[0] for q in boundary[j]]\n",
    "\n",
    "        boundary_out = 0\n",
    "        for q in boundary_qubits:\n",
    "            boundary_out += final_outs[q]\n",
    "        boundary_out = boundary_out % 2\n",
    "\n",
    "        if boundary_out == 1:\n",
    "            node = {\n",
    "                'time': 0,\n",
    "                'basis': self.basis,\n",
    "                'qubits': boundary_qubits,\n",
    "                'element': 0,\n",
    "                'is_boundary': True\n",
    "                }\n",
    "            nodes.append(node)\n",
    "\n",
    "        return(nodes)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example with two measurement rounds and some noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = 2\n",
    "p = 0.1\n",
    "hhc = CssCodeCircuit(code,2,basis='z',p_depol=p,p_meas=p)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Currently we need `Aer` to run it, but we should find a way to get Stim to do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts = AerSimulator().run(hhc.circuit['0']).result().get_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To have some test that this is working somewhat correctly, we can look at the average number of nodes created by the noise. This should be zero when there is no error, and non-zero when there is some."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00390625"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "av_num = 0\n",
    "for string in counts:\n",
    "    av_num = len(hhc.string2nodes(string))*counts[string]\n",
    "av_num = av_num/sum(counts.values())\n",
    "av_num"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make a decoding graph, we'll need to use a version with no noise operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "hhc = CssCodeCircuit(code,2,basis='z')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we just do the thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_qec.decoders import DecodingGraph\n",
    "\n",
    "dg = DecodingGraph(hhc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does it look like a decoding graph?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from rustworkx.visualization import mpl_draw\n",
    "\n",
    "mpl_draw(dg.graph)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, I guess. Obviously this all needs proper testing."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To Do\n",
    "\n",
    "For now:\n",
    "\n",
    "* Use stim for counts generation;\n",
    "* Use stim for a `make_syndrome_graph` method.\n",
    "\n",
    "For later:\n",
    "\n",
    "* Create `CssCode` class, and make all existing CSS codes in `qiskit_qec.codes` inheret from it;\n",
    "* Extend `CssCodeCircuit` to allow user-defined fault-tolerant circuits;\n",
    "* Retire `SurfaceCodeCircuit` in favour of a version created by from a `CssCode` that is created by the `SurfaceCodeBuilder`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "arc-decoder",
   "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.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "03129f355ee4a9ac18d094f888c5b06a42548fdd2b980a4388a8afbc8ddd4684"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}