{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "edfa713d",
   "metadata": {},
   "source": [
    "# Pseudo Random Number Generation for randomized benchmarking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "362b1bd7",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### Main goal and related challenge\n",
    "**goal:** we typically want to play a large (30k+) number of Clifford gates, for randomized benchmarking sequences (to\n",
    "be able to probe very small error rates such as in [this paper](https://arxiv.org/abs/2412.04421))\n",
    "\n",
    "**problem:** playing a Clifford gate requires uploading a few Q1 instructions to the sequencer (grossly 3 to 10 depending\n",
    "on the gate). Yet the number of instructions than can be uploaded on a sequencer is limited (12288 for QRM sequencers,\n",
    "16384 for QCM and QTM sequencers). That means that we are a priori limited to ~10k gates long sequences in a randomized\n",
    "benchmarking (RB) sequence: it is possible to save some instruction memory using a lookup table of gates and simply uploading\n",
    "a sequences of gate indices, but even this technique will not allow to reach the 100k+ gates regime. If one tries to\n",
    "upload the complete description of the sequence with Q1 instruction, we will always it a memory overflow at some point.\n",
    "\n",
    "**Possible solution: the “Oracle“ approach**. Even though it is not possible to upload the complete RB sequence onto the\n",
    "instrument, this sequence can be generated on the fly, at the sequencer level. It means that the random choices (the\n",
    "RNG) should be implemented in Q1.\n",
    "\n",
    "A key caveat in a randomized benchmarking sequence is that the gate applied at the end of the sequence must\n",
    "be chosen such that the net product of all the gates of the sequence is equal to the identity: this is why we call this last\n",
    "gate the “recovery“ gate.\n",
    "\n",
    "A priori, it is difficult to store the sequence of gates due to be played in the instruments memory, and compute\n",
    "thereafter the recovery gate on the fly. However, it is not useful either: since the RNG is only pseudo-random (predetermined\n",
    "by a seed) one can compute beforehand in python what the (pseudo) random sequence will be, and therefore predict\n",
    "the appropriate recovery operation. It can then be uploaded manually to the sequencer, and played after the execution of the sequence.\n",
    "\n",
    "\n",
    "In summary, the solution involves the following steps:\n",
    "\n",
    "1. **Initialize the parameters (Host PC):**\n",
    "  - Set a **SEED** and a desired number **N** of gates to be played.\n",
    "2. **Pre-compute the recovery gate (Host PC):**\n",
    "  - Using the **SEED**, number of gates **N**, and the known **RNG algorithm** (e.g., `xorshift32`),\n",
    "    calculate the appropriate **recovery gate**.\n",
    "  - Prepare the program to be uploaded to the **instrument**, including the **RNG recipe** and the **pre-computed\n",
    "    recovery gate**.\n",
    "3. **Upload and run the program on the instrument.**\n",
    "  - The Q1ASM program contains:\n",
    "      - The **RNG algorithm** and the **SEED**.\n",
    "      - Looping instructions to play **(N-1)** gates.\n",
    "      - The **pre-computed recovery gate** to be applied at the end."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d97b88c",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "This approach suffers from a time limitation concerning the minimal duration of the gates that are being\n",
    "played. Indeed, the randomization process is carried out by a succession of assembly operation implemented in the Q1ASM\n",
    "language, the compilation of each instruction by the classical core of the instrument takes a few ns\n",
    "[see here for more info](https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html). In total, the\n",
    "processing time of the RNG, and then remapping onto a given gate index, takes roughly 300ns, which is then a lower bound\n",
    "to the gate duration that are executed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25da3719",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "46477316",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:10.007651Z",
     "iopub.status.busy": "2025-03-12T18:08:10.007372Z",
     "iopub.status.idle": "2025-03-12T18:08:10.630963Z",
     "shell.execute_reply": "2025-03-12T18:08:10.630270Z"
    }
   },
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "from typing import TYPE_CHECKING, Callable\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from one_qubit_clifford_group import SingleQubitClifford as SQC  # noqa: N817\n",
    "from qcodes.instrument import find_or_create_instrument\n",
    "from rb_utils import generate_main_rb_script, randomized_benchmarking_sequence\n",
    "\n",
    "from qblox_instruments import Cluster, ClusterType\n",
    "\n",
    "if TYPE_CHECKING:\n",
    "    from q1_generator import SequenceProgram\n",
    "\n",
    "    from qblox_instruments.qcodes_drivers.module import Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50758637",
   "metadata": {},
   "source": [
    "Let's regenerate the one qubit Clifford group lookup table, with the `clifford_lookup_table_generator.py` module. It\n",
    "creates a json file indexing the elements of the group with:\n",
    "- their Pauli transfer matrix representation\n",
    "- the index of their corresponding inverse element\n",
    "- a unique identification hash number\n",
    "\n",
    "This dictionary is then loaded by the `SingleQubitClifford` class, as a class attribute.\n",
    "\n",
    "To execute the module, we use the jupyter `%run` magic command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ec617f58",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:10.633860Z",
     "iopub.status.busy": "2025-03-12T18:08:10.633694Z",
     "iopub.status.idle": "2025-03-12T18:08:10.644392Z",
     "shell.execute_reply": "2025-03-12T18:08:10.643728Z"
    }
   },
   "outputs": [],
   "source": [
    "%run \"clifford_lookup_table_generator.py\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86c724d3",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "## Preliminary: main settings and connection to cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7680fffd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:10.648128Z",
     "iopub.status.busy": "2025-03-12T18:08:10.647932Z",
     "iopub.status.idle": "2025-03-12T18:08:13.909661Z",
     "shell.execute_reply": "2025-03-12T18:08:13.907852Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: <Module: cluster0_module2 of Cluster: cluster0>, 4: <Module: cluster0_module4 of Cluster: cluster0>, 6: <Module: cluster0_module6 of Cluster: cluster0>, 8: <Module: cluster0_module8 of Cluster: cluster0>, 10: <Module: cluster0_module10 of Cluster: cluster0>}\n"
     ]
    }
   ],
   "source": [
    "def get_connected_modules(cluster: Cluster, filter_fn: Callable | None = None) -> dict[int, Module]:\n",
    "    def checked_filter_fn(mod: ClusterType) -> bool:\n",
    "        if filter_fn is not None:\n",
    "            return filter_fn(mod)\n",
    "        return True\n",
    "\n",
    "    return {\n",
    "        mod.slot_idx: mod for mod in cluster.modules if mod.present() and checked_filter_fn(mod)\n",
    "    }\n",
    "\n",
    "\n",
    "cluster_ip = \"10.10.200.42\"\n",
    "cluster_name = \"cluster0\"\n",
    "\n",
    "cluster = find_or_create_instrument(\n",
    "    Cluster,\n",
    "    recreate=True,\n",
    "    name=cluster_name,\n",
    "    identifier=cluster_ip,\n",
    "    debug=True,\n",
    "    dummy_cfg=(\n",
    "        {\n",
    "            2: ClusterType.CLUSTER_QCM,\n",
    "            4: ClusterType.CLUSTER_QRM,\n",
    "            6: ClusterType.CLUSTER_QCM_RF,\n",
    "            8: ClusterType.CLUSTER_QRM_RF,\n",
    "        }\n",
    "        if cluster_ip is None\n",
    "        else None\n",
    "    ),\n",
    ")\n",
    "\n",
    "cluster.reset()\n",
    "print(get_connected_modules(cluster))\n",
    "\n",
    "\n",
    "# QRM baseband modules\n",
    "qrm_modules = get_connected_modules(cluster, lambda mod: mod.is_qrm_type and not mod.is_rf_type)\n",
    "qrm_module = list(qrm_modules.values())[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bf289b4",
   "metadata": {},
   "source": [
    "## Main implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ca7d5e1",
   "metadata": {},
   "source": [
    "### Oracle for the recovery gate computation\n",
    "\n",
    "We want to simulate the outcome of the random number generator on the computer, before\n",
    "running it on the instrument (so that we can compute the recovery gate beforehand).\n",
    "We call this approach \"oracle\". We choose to implement the `Xorshift32` algorithm to perform\n",
    "the RNG, because it is quite simple to do and only involves basic bitwise operations\n",
    "(logical bit shifts and XOR operations).\n",
    "\n",
    ".. important::\n",
    "  The pythonic implementation of the `Xorshift32`, as well as the subsequent computation\n",
    "  of the correct sequence of gates (given the seed and the length) is implemented in the\n",
    "  `xorshift`, `generate_random_sequence` and `randomized_benchmarking_sequence` functions\n",
    "  of the `rb_utils.py` module."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4834df32",
   "metadata": {},
   "source": [
    "- we generate a sequence of a given length (e.g. 30) where the first 29 gates are random, and the last gate is chosen\n",
    "to ensure the net product product of all the gates, is the identity operator;\n",
    "- we double check that the gate generation is correct by computing the net gate and comparing it to the identity ;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f916d8cc",
   "metadata": {},
   "source": [
    "This notebook demonstrates an example of randomized benchmarking of **single qubit** gates.\n",
    "We therefore make use of the single qubit Clifford group, containing 24 elements.\n",
    "That means that the 32-bits random number coming out of the `Xorshift32` loop must\n",
    "be remapped onto the [0, 23] integer range. This feature is again achieved with Q1ASM\n",
    "instructions. The principle is shown with the figure below: the first 3 bits\n",
    "$b_{32}\\,b_{31}\\,b_{30}$ of the random number $x_{rand}$ are used to\n",
    "select a group of 3 potential numbers, and the remaining 29 bits are used to select\n",
    "which one of three candidates is kept. This method actually relies on the fact that\n",
    "$24=2^3 \\times 3$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ce88f76",
   "metadata": {},
   "source": [
    "![remapping image](remapping_24.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1c5c5485",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:13.914467Z",
     "iopub.status.busy": "2025-03-12T18:08:13.914040Z",
     "iopub.status.idle": "2025-03-12T18:08:13.936224Z",
     "shell.execute_reply": "2025-03-12T18:08:13.934636Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence of gates: [0, 0, 14, 1, 13, 4, 3, 2, 11, 16, 14, 8, 16, 0, 0, 18, 4, 18, 1, 23, 13, 21, 7, 20, 0, 8, 13, 1, 5, 8]\n",
      "Number of gates: 30\n",
      "Gate sequence generation succeeded: True\n"
     ]
    }
   ],
   "source": [
    "# generate a random sequence of 30 gates that realizes in total the desired Clifford operator\n",
    "rb_clifford_indices = randomized_benchmarking_sequence(\n",
    "    seed=1,\n",
    "    number_of_gates=30,\n",
    "    desired_net_clifford=0,  # 0 is the index of the identity: print(SQC._gates_names_dict) to verify it\n",
    ")\n",
    "print(f\"Sequence of gates: {rb_clifford_indices}\")\n",
    "print(f\"Number of gates: {len(rb_clifford_indices)}\")\n",
    "\n",
    "# We check that the sequence of gates realizes the identity\n",
    "success = (\n",
    "    SQC.get_clifford_index_from_PLT(\n",
    "        np.linalg.multi_dot(\n",
    "            [SQC(i).pauli_transfer_matrix for i in list(reversed(rb_clifford_indices))]\n",
    "        )\n",
    "    )\n",
    "    == 0\n",
    ")\n",
    "print(f\"Gate sequence generation succeeded: {success}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46f0fb28",
   "metadata": {},
   "source": [
    "### Q1 implementation of the xorshift RNG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "52b34086",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:13.940283Z",
     "iopub.status.busy": "2025-03-12T18:08:13.939878Z",
     "iopub.status.idle": "2025-03-12T18:08:13.946308Z",
     "shell.execute_reply": "2025-03-12T18:08:13.945022Z"
    }
   },
   "outputs": [],
   "source": [
    "SEED = 789456123\n",
    "NUMBER_OF_GATES = 30\n",
    "GATE_DURATION = 500  # ns\n",
    "\n",
    "# Register indices\n",
    "LOOP_COUNTER_REGISTER_INDEX = 0\n",
    "RECOVERY_GATE_PLAYED_MARKER = 1\n",
    "XORSHIFT_OUTPUT_REGISTER_INDEX = 61\n",
    "WORKING_REGISTER_INDEX = 62\n",
    "GATE_INDEX_REGISTER = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97d6bdd3",
   "metadata": {},
   "source": [
    ".. note::\n",
    "  `generate_main_rb_script` is a function that automatically created the Q1ASM code snippet\n",
    "  that needs to be uploaded to the sequencer. It is implemented in the `rb_utils.py` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b58f4cdc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:13.950271Z",
     "iopub.status.busy": "2025-03-12T18:08:13.949876Z",
     "iopub.status.idle": "2025-03-12T18:08:13.966156Z",
     "shell.execute_reply": "2025-03-12T18:08:13.964818Z"
    }
   },
   "outputs": [],
   "source": [
    "seq_prog: SequenceProgram = generate_main_rb_script(\n",
    "    SEED,\n",
    "    NUMBER_OF_GATES,\n",
    "    LOOP_COUNTER_REGISTER_INDEX,\n",
    "    RECOVERY_GATE_PLAYED_MARKER,\n",
    "    XORSHIFT_OUTPUT_REGISTER_INDEX,\n",
    "    WORKING_REGISTER_INDEX,\n",
    "    GATE_INDEX_REGISTER,\n",
    ")\n",
    "\n",
    "# start acquisition\n",
    "seq_prog.insert_instruction(\n",
    "    seq_prog.format_instructions((\"acquire\", \"0,0,200\", None)), label=\"start\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bcefb15b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:13.969912Z",
     "iopub.status.busy": "2025-03-12T18:08:13.969491Z",
     "iopub.status.idle": "2025-03-12T18:08:13.981164Z",
     "shell.execute_reply": "2025-03-12T18:08:13.979881Z"
    }
   },
   "outputs": [],
   "source": [
    "sequence_of_gates = randomized_benchmarking_sequence(seed=SEED, number_of_gates=NUMBER_OF_GATES)\n",
    "recovery_gate_index = sequence_of_gates[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "023c0a8a",
   "metadata": {},
   "source": [
    "### Implementation of the gates\n",
    "\n",
    "Here the gates are simply DC offsets that explores the full QRM output range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1610ae26",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:13.985178Z",
     "iopub.status.busy": "2025-03-12T18:08:13.984760Z",
     "iopub.status.idle": "2025-03-12T18:08:14.003474Z",
     "shell.execute_reply": "2025-03-12T18:08:14.002168Z"
    },
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "min_offset, max_offset = -32768, 32767\n",
    "\n",
    "SINGLE_QUBIT_CLIFFORD_GROUP_ORDER = 24\n",
    "\n",
    "for i in range(SINGLE_QUBIT_CLIFFORD_GROUP_ORDER):\n",
    "    label = f\"clifford_{i}\"\n",
    "    offset = int(\n",
    "        min_offset + (max_offset - min_offset) * i / 23\n",
    "    )  # mapping onto the range of the offset\n",
    "    seq_prog.add_label(label)\n",
    "    seq_prog.add_awg_instruction(values=(offset, offset), instruction_type=\"offset\", label=label)\n",
    "    seq_prog.add_update_parameters(duration=GATE_DURATION, label=label)\n",
    "    seq_prog.add_jump(jump_to=\"loop\", label=label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec9d5b20",
   "metadata": {},
   "source": [
    "### Showing the final Q1 script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5a0f003",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:14.007323Z",
     "iopub.status.busy": "2025-03-12T18:08:14.006930Z",
     "iopub.status.idle": "2025-03-12T18:08:14.013812Z",
     "shell.execute_reply": "2025-03-12T18:08:14.012472Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------------------------------\n",
      "init:\n",
      "\twait_sync       4                   # wait for synchronization\n",
      "\treset_ph                            # reset absolute phase and time to 0\n",
      "\tupd_param       4                   # update all parameters and wait 4ns\n",
      "start:\n",
      "\tmove            29,R0               # iterations counter\n",
      "\tmove            2,R1                # recovery gate played marker\n",
      "\tmove            789456123,R61       # initial seed value\n",
      "\tnop\n",
      "\tset_mrk         15                  # turn all markers channels ON\n",
      "\tupd_param       8\n",
      "\tset_mrk         0                   # turn all markers channels OFF\n",
      "\tupd_param       4\n",
      "\tacquire         0,0,200\n",
      "main:\n",
      "\tjmp             @xorshift           # jump to label @xorshift\n",
      "loop:\n",
      "\tloop            R0,@main            # if val(R0-1)>0: go to 'main' and continue from there again\n",
      "\tadd             R0,1,R0             # to prevent R0 taking neg. values after playing recov. gate\n",
      "recovery:\n",
      "\tloop            R1,@clifford_6      # R1=1 => play recov. gate -> goto @loop -> R1=0 => skip\n",
      "stop:\n",
      "\tset_awg_offs    0,0                 # set AWG offset to 0\n",
      "\tupd_param       4                   # update all parameters and wait 4ns\n",
      "\tstop                                # stop the sequencer\n",
      "xorshift:\n",
      "\tasl             R61,13,R62\n",
      "\tnop\n",
      "\txor             R61,R62,R61\n",
      "\tnop\n",
      "\tasr             R61,17,R62\n",
      "\tnop\n",
      "\txor             R61,R62,R61\n",
      "\tnop\n",
      "\tasl             R61,5,R62\n",
      "\tnop\n",
      "\txor             R61,R62,R61\n",
      "\tnop\n",
      "\tasr             R61,29,R50          # isolating the first 3 bits\n",
      "\tnop\n",
      "\tasl             R50,2,R50           # making room for 00 01 and 10\n",
      "\tnop\n",
      "\tand             R61,536870911,R62   # isolating the last 29 bits\n",
      "\tnop\n",
      "\tjlt             R62,178956970,@shift # 00 case\n",
      "\tnop\n",
      "\tadd             R50,1,R50\n",
      "\tnop\n",
      "\tjlt             R62,357913940,@shift # 01 case\n",
      "\tnop\n",
      "\tadd             R50,1,R50\n",
      "\tnop\n",
      "\tjmp             @shift              # 10 case\n",
      "shift:\n",
      "\tadd             R50,@gatesLUT,R50   # add @gatesLUT to register R50\n",
      "\tnop\n",
      "\tjmp             R50                 # jump to register R50\n",
      "gatesLUT:\n",
      "\tjmp             @clifford_0         # jump to label @clifford_0\n",
      "\tjmp             @clifford_1         # jump to label @clifford_1\n",
      "\tjmp             @clifford_2         # jump to label @clifford_2\n",
      "\tnop\n",
      "\tjmp             @clifford_3         # jump to label @clifford_3\n",
      "\tjmp             @clifford_4         # jump to label @clifford_4\n",
      "\tjmp             @clifford_5         # jump to label @clifford_5\n",
      "\tnop\n",
      "\tjmp             @clifford_6         # jump to label @clifford_6\n",
      "\tjmp             @clifford_7         # jump to label @clifford_7\n",
      "\tjmp             @clifford_8         # jump to label @clifford_8\n",
      "\tnop\n",
      "\tjmp             @clifford_9         # jump to label @clifford_9\n",
      "\tjmp             @clifford_10        # jump to label @clifford_10\n",
      "\tjmp             @clifford_11        # jump to label @clifford_11\n",
      "\tnop\n",
      "\tjmp             @clifford_12        # jump to label @clifford_12\n",
      "\tjmp             @clifford_13        # jump to label @clifford_13\n",
      "\tjmp             @clifford_14        # jump to label @clifford_14\n",
      "\tnop\n",
      "\tjmp             @clifford_15        # jump to label @clifford_15\n",
      "\tjmp             @clifford_16        # jump to label @clifford_16\n",
      "\tjmp             @clifford_17        # jump to label @clifford_17\n",
      "\tnop\n",
      "\tjmp             @clifford_18        # jump to label @clifford_18\n",
      "\tjmp             @clifford_19        # jump to label @clifford_19\n",
      "\tjmp             @clifford_20        # jump to label @clifford_20\n",
      "\tnop\n",
      "\tjmp             @clifford_21        # jump to label @clifford_21\n",
      "\tjmp             @clifford_22        # jump to label @clifford_22\n",
      "\tjmp             @clifford_23        # jump to label @clifford_23\n",
      "\tnop\n",
      "clifford_0:\n",
      "\tset_awg_offs    -32768,-32768\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_1:\n",
      "\tset_awg_offs    -29918,-29918\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_2:\n",
      "\tset_awg_offs    -27069,-27069\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_3:\n",
      "\tset_awg_offs    -24219,-24219\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_4:\n",
      "\tset_awg_offs    -21370,-21370\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_5:\n",
      "\tset_awg_offs    -18521,-18521\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_6:\n",
      "\tset_awg_offs    -15671,-15671\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_7:\n",
      "\tset_awg_offs    -12822,-12822\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_8:\n",
      "\tset_awg_offs    -9973,-9973\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_9:\n",
      "\tset_awg_offs    -7123,-7123\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_10:\n",
      "\tset_awg_offs    -4274,-4274\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_11:\n",
      "\tset_awg_offs    -1425,-1425\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_12:\n",
      "\tset_awg_offs    1424,1424\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_13:\n",
      "\tset_awg_offs    4273,4273\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_14:\n",
      "\tset_awg_offs    7122,7122\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_15:\n",
      "\tset_awg_offs    9972,9972\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_16:\n",
      "\tset_awg_offs    12821,12821\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_17:\n",
      "\tset_awg_offs    15670,15670\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_18:\n",
      "\tset_awg_offs    18520,18520\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_19:\n",
      "\tset_awg_offs    21369,21369\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_20:\n",
      "\tset_awg_offs    24218,24218\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_21:\n",
      "\tset_awg_offs    27068,27068\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_22:\n",
      "\tset_awg_offs    29917,29917\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "clifford_23:\n",
      "\tset_awg_offs    32767,32767\n",
      "\tupd_param       500                 # updating batched parameters\n",
      "\tjmp             @loop               # jump to label @loop\n",
      "----------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"-\" * 88)\n",
    "print(seq_prog.seq_prog)\n",
    "print(\"-\" * 88)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "518a172e",
   "metadata": {},
   "source": [
    "## Upload and run the sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c422507a",
   "metadata": {},
   "source": [
    "We run the script and acquire the signal on a QRM in loopback configuration (output O¹\n",
    "connected to input I¹ and same thing for [O², I²])."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "afd88bc6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:14.017696Z",
     "iopub.status.busy": "2025-03-12T18:08:14.017309Z",
     "iopub.status.idle": "2025-03-12T18:08:16.518312Z",
     "shell.execute_reply": "2025-03-12T18:08:16.516902Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cluster initial status: Status: OKAY, Flags: NONE, Slot flags: NONE\n",
      "Cluster final status: Status: OKAY, Flags: NONE, Slot flags: NONE\n",
      "\n",
      "Sequencer final status:\n",
      "-----------------------\n",
      "Status: WARNING, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: OUTPUT_OVERFLOW, Error Flags: NONE, Log: []\n"
     ]
    }
   ],
   "source": [
    "# Acquisitions\n",
    "acquisitions = {\"single\": {\"num_bins\": 1, \"index\": 0}}\n",
    "\n",
    "# Sequence dict generation\n",
    "sequence = {\n",
    "    \"waveforms\": {},  # waveforms_dict,\n",
    "    \"weights\": {},\n",
    "    \"acquisitions\": acquisitions,\n",
    "    \"program\": seq_prog.seq_prog,\n",
    "}\n",
    "\n",
    "# Reset cluster and check status\n",
    "cluster.reset()\n",
    "print(f\"Cluster initial status: {cluster.get_system_status()}\")\n",
    "\n",
    "# Load the sequence\n",
    "qrm_module.sequencer0.sequence(sequence)\n",
    "\n",
    "# Synchronize the modules\n",
    "qrm_module.sequencer0.sync_en(True)\n",
    "\n",
    "# Connect the sequencer and arm it\n",
    "qrm_module.disconnect_outputs()\n",
    "qrm_module.disconnect_inputs()\n",
    "\n",
    "\n",
    "qrm_module.sequencer0.connect_sequencer(\"io0_1\")\n",
    "\n",
    "qrm_module.scope_acq_trigger_mode_path0(\"sequencer\")\n",
    "qrm_module.scope_acq_trigger_mode_path1(\"sequencer\")\n",
    "\n",
    "qrm_module.arm_sequencer(0)\n",
    "\n",
    "# Start the sequence\n",
    "cluster.start_sequencer()\n",
    "\n",
    "print(f\"Cluster final status: {cluster.get_system_status()}\\n\")\n",
    "print(\"Sequencer final status:\")\n",
    "print(\"-----------------------\")\n",
    "print(qrm_module.sequencer0.get_sequencer_status())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a236797",
   "metadata": {},
   "source": [
    "### Checking out the resulting data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0e6dfb01",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:16.522069Z",
     "iopub.status.busy": "2025-03-12T18:08:16.521746Z",
     "iopub.status.idle": "2025-03-12T18:08:16.556739Z",
     "shell.execute_reply": "2025-03-12T18:08:16.555597Z"
    }
   },
   "outputs": [],
   "source": [
    "# Wait for the acquisition to finish with a timeout period of one minute.\n",
    "qrm_module.get_acquisition_status(0)\n",
    "\n",
    "# Move acquisition data from temporary memory to acquisition list.\n",
    "qrm_module.store_scope_acquisition(0, \"single\")\n",
    "\n",
    "# Get acquisition list from instrument.\n",
    "single_acq = qrm_module.get_acquisitions(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59125134",
   "metadata": {},
   "source": [
    "The input ADC of the QRM module needs to be calibrated. In the following we will use calibration constants that we\n",
    "measured manually. More information about how one can calibrate the ADC can be found in [this documentation page](https://docs.qblox.com/en/main/tutorials/q1asm_tutorials/basic/generated/QRM/050_calibrate_adc.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1aba8b47",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:16.560027Z",
     "iopub.status.busy": "2025-03-12T18:08:16.559725Z",
     "iopub.status.idle": "2025-03-12T18:08:16.739594Z",
     "shell.execute_reply": "2025-03-12T18:08:16.738614Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x621 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# INPUT0 CALIBRATION\n",
    "I0_CALIBRATED_OFFSET = 0.013182311624099292\n",
    "I0_CALIBRATED_MAX = 0.5377562325869412\n",
    "I0_CALIBRATED_MIN = -0.5387479589128147\n",
    "\n",
    "# INPUT1 CALIBRATION\n",
    "I1_CALIBRATED_OFFSET = -0.009603063362542746\n",
    "I1_CALIBRATED_MAX = 0.5303539378129579\n",
    "I1_CALIBRATED_MIN = -0.5307611379076087\n",
    "\n",
    "i0_data_rng = np.array(single_acq[\"single\"][\"acquisition\"][\"scope\"][\"path0\"][\"data\"])\n",
    "i0_data_rng -= I0_CALIBRATED_OFFSET\n",
    "\n",
    "i1_data_rng = np.array(single_acq[\"single\"][\"acquisition\"][\"scope\"][\"path1\"][\"data\"])\n",
    "i1_data_rng -= I1_CALIBRATED_OFFSET\n",
    "\n",
    "# remapping the data to the range [0, 23] range\n",
    "i0_data = 23 * (i0_data_rng - I0_CALIBRATED_MIN) / (I0_CALIBRATED_MAX - I0_CALIBRATED_MIN)\n",
    "i1_data = 23 * (i1_data_rng - I1_CALIBRATED_MIN) / (I1_CALIBRATED_MAX - I1_CALIBRATED_MIN)\n",
    "\n",
    "# trimming and rounding\n",
    "i0_data = i0_data.round().astype(int)\n",
    "i1_data = i1_data.round().astype(int)\n",
    "\n",
    "# Plot acquired signal on both inputs.\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "ax.plot(i1_data)\n",
    "ax.set_xlabel(\"Time (ns)\")\n",
    "ax.set_ylabel(\"Relative amplitude\")\n",
    "ax.set_yticks(range(24))\n",
    "ax.grid(which=\"both\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "df205d29",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:16.741754Z",
     "iopub.status.busy": "2025-03-12T18:08:16.741565Z",
     "iopub.status.idle": "2025-03-12T18:08:16.746599Z",
     "shell.execute_reply": "2025-03-12T18:08:16.745792Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[14, 1, 20, 4, 9, 20, 17, 1, 2, 6, 20, 5, 14, 10, 8, 16, 14, 7, 13, 13, 10, 3, 23, 11, 5, 19, 14, 7, 22, 6]\n"
     ]
    }
   ],
   "source": [
    "# checking that the sequence is correct\n",
    "print(sequence_of_gates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "35f666ee",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-12T18:08:16.748754Z",
     "iopub.status.busy": "2025-03-12T18:08:16.748589Z",
     "iopub.status.idle": "2025-03-12T18:08:16.755937Z",
     "shell.execute_reply": "2025-03-12T18:08:16.755312Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We check that the sequence of gates realizes the desired π/2 pulse\n",
    "SQC.get_clifford_index_from_PLT(\n",
    "    np.linalg.multi_dot([SQC(i).pauli_transfer_matrix for i in list(reversed(sequence_of_gates))])\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "files_to_bundle_in_zip_file": [
   "clifford_lookup_table_generator.py",
   "clifford_lookup_tables/single_qubit_lut.json",
   "one_qubit_clifford_group.py",
   "q1_generator.py",
   "rb_utils.py",
   "remapping_24.png"
  ],
  "jupytext": {
   "notebook_metadata_filter": "files_to_bundle_in_zip_file"
  },
  "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.9.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}