examples/braket_features/Allocating_Qubits_on_QPU_Devices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Allocating Qubits on QPU Devices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "\n",
    "t = Tracker().start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook demonstrates how you can specify explicitly which qubits to use when you run a quantum circuit on QPU devices from Rigetti.\n",
    "\n",
    "When you submit a circuit for execution on a QPU, Amazon Braket performs a series of compilation steps: it maps the _abstract qubits_ in your circuit to _physical qubits_ in the device; it synthesizes gates into the native gate set of the device; it optimizes the circuit to reduce the number of gates; and finally, it translates the gates into executable pulses.\n",
    "\n",
    "This section shows how the first step, called qubit allocation, works for the Rigetti Ankaa-3 device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# general imports\n",
    "import random\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from braket.aws import AwsDevice\n",
    "from braket.circuits import Circuit\n",
    "from braket.devices import Devices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Automatic qubit allocation\n",
    "\n",
    "Qubit allocation for Rigetti devices on Amazon Braket utilizes [the Quil Compilers](https://pyquil-docs.rigetti.com/en/latest/compiler.html#the-quil-compiler)'s _rewiring_ strategies. By default, when you submit a circuit on Amazon Braket to a Rigetti device, the circuit is rewired according to the [PARTIAL](https://pyquil-docs.rigetti.com/en/latest/compiler.html#partial) rewiring strategy. Specifically, the compiler starts with an empty mapping from logical to physical qubits. Taking into account the latest calibration data of the device, the compiler fills in the mapping with the goal, sequentially, to maximize the overall fidelity of the circuit.\n",
    "\n",
    "The example that follows shows how to create a GHZ state on qubits that are not physically connected. After the quantum task is completed, you can obtain a list of the actual gates executed on the device, by viewing the result metadata.\n",
    "\n",
    "First, instantiate the Rigetti Ankaa-3 device and retrieve its connectivity graph, which shows the qubits that are directly connected on the chip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the connectivity of Ankaa-3 is: {'0': ['1', '7'], '1': ['0', '2', '8'], '2': ['1', '3', '9'], '3': ['2', '4', '10'], '4': ['3', '5', '11'], '5': ['4', '6', '12'], '6': ['5', '13'], '7': ['0', '8', '14'], '8': ['1', '7', '9', '15'], '9': ['2', '8', '10', '16'], '10': ['3', '9', '11'], '11': ['4', '10', '12', '18'], '12': ['5', '11', '13', '19'], '13': ['6', '12', '20'], '14': ['7', '15', '21'], '15': ['8', '14', '16', '22'], '16': ['9', '15', '17', '23'], '17': ['16', '18', '24'], '18': ['11', '17', '19', '25'], '19': ['12', '18', '20', '26'], '20': ['13', '19', '27'], '21': ['14', '22', '28'], '22': ['15', '21', '23', '29'], '23': ['16', '22', '24', '30'], '24': ['17', '23', '25', '31'], '25': ['18', '24', '26', '32'], '26': ['19', '25', '27', '33'], '27': ['20', '26'], '28': ['21', '29', '35'], '29': ['22', '28', '30', '36'], '30': ['23', '29', '31', '37'], '31': ['24', '30', '38'], '32': ['25', '33', '39'], '33': ['26', '32', '34', '40'], '34': ['33', '41'], '35': ['28', '36'], '36': ['29', '35', '37', '43'], '37': ['30', '36', '38', '44'], '38': ['31', '37', '39', '45'], '39': ['32', '38', '40', '46'], '40': ['33', '39', '41', '47'], '41': ['34', '40'], '43': ['36', '50'], '44': ['37', '45', '51'], '45': ['38', '44', '46', '52'], '46': ['39', '45', '47', '53'], '47': ['40', '46', '54'], '49': ['50', '56'], '50': ['43', '49', '51', '57'], '51': ['44', '50', '52', '58'], '52': ['45', '51', '53', '59'], '53': ['46', '52', '54', '60'], '54': ['47', '53', '55', '61'], '55': ['54', '62'], '56': ['49', '57', '63'], '57': ['50', '56', '58', '64'], '58': ['51', '57', '59', '65'], '59': ['52', '58', '60', '66'], '60': ['53', '59', '61', '67'], '61': ['54', '60', '62', '68'], '62': ['55', '61', '69'], '63': ['56', '64', '70'], '64': ['57', '63', '65', '71'], '65': ['58', '64', '66', '72'], '66': ['59', '65', '73'], '67': ['60', '68', '74'], '68': ['61', '67', '69', '75'], '69': ['62', '68', '76'], '70': ['63', '71', '77'], '71': ['64', '70', '72', '78'], '72': ['65', '71', '73', '79'], '73': ['66', '72', '74', '80'], '74': ['67', '73', '75', '81'], '75': ['68', '74', '76', '82'], '76': ['69', '75', '83'], '77': ['70', '78'], '78': ['71', '77', '79'], '79': ['72', '78', '80'], '80': ['73', '79', '81'], '81': ['74', '80', '82'], '82': ['75', '81', '83'], '83': ['76', '82']}\n"
     ]
    }
   ],
   "source": [
    "device = AwsDevice(Devices.Rigetti.Ankaa3)\n",
    "\n",
    "connectivity_graph = device.properties.paradigm.connectivity.connectivityGraph\n",
    "print(f\"the connectivity of {device.name} is: {connectivity_graph}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Next, create a GHZ circuit with three qubits 0, 2, 4, and run it on the Ankaa-3 device. Notice that none of these qubits are connected on the Ankaa-3 connectivity graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │\n",
      "      ┌───┐             \n",
      "q0 : ─┤ H ├───●─────●───\n",
      "      └───┘   │     │   \n",
      "            ┌─┴─┐   │   \n",
      "q2 : ───────┤ X ├───┼───\n",
      "            └───┘   │   \n",
      "                  ┌─┴─┐ \n",
      "q4 : ─────────────┤ X ├─\n",
      "                  └───┘ \n",
      "T  : │  0  │  1  │  2  │\n"
     ]
    }
   ],
   "source": [
    "# create a GHZ state with non-neighboring qubits\n",
    "circuit = Circuit()\n",
    "circuit.h(0).cnot(0, 2).cnot(0, 4)\n",
    "print(circuit)\n",
    "\n",
    "rigetti_rewiring = device.run(circuit, shots=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "print(\"Status of quantum task:\", rigetti_rewiring.state())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "To verify the final qubit allocation, retrieve the compiled program that was executed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'111': 4, '000': 4, '011': 1, '010': 1})\n",
      "The compiled circuit is:\n",
      " PRAGMA INITIAL_REWIRING \"NAIVE\"\n",
      "DECLARE ro BIT[3]\n",
      "PRAGMA PRESERVE_BLOCK\n",
      "RX(1.5707963267948966) 77\n",
      "RZ(3.141592653589793) 77\n",
      "ISWAP 77 70\n",
      "RZ(1.5707963267948966) 77\n",
      "RX(1.5707963267948966) 77\n",
      "RZ(4.71238898038469) 77\n",
      "ISWAP 77 70\n",
      "RZ(3.141592653589793) 70\n",
      "RZ(1.5707963267948966) 77\n",
      "RX(1.5707963267948966) 70\n",
      "ISWAP 77 78\n",
      "RZ(1.5707963267948966) 77\n",
      "RX(1.5707963267948966) 77\n",
      "RZ(4.71238898038469) 77\n",
      "ISWAP 77 78\n",
      "RZ(3.141592653589793) 78\n",
      "RX(1.5707963267948966) 78\n",
      "PRAGMA END_PRESERVE_BLOCK\n",
      "MEASURE 70 ro[1]\n",
      "MEASURE 77 ro[0]\n",
      "MEASURE 78 ro[2]\n"
     ]
    }
   ],
   "source": [
    "result = rigetti_rewiring.result()\n",
    "counts = result.measurement_counts\n",
    "print(\"Measurement counts:\", counts)\n",
    "print(\"The compiled circuit is:\\n\", result.additional_metadata.rigettiMetadata.compiledProgram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Notice that the PARTIAL rewiring was applied. The qubits 0, 2, 4 in the original circuit were mapped to three other qubits in the Rigetti device, and the gates were compiled into native gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User-defined qubit allocation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Amazon Braket, you can choose to prescribe a qubit mapping manually, and prevent further rewiring for Rigetti devices. To enable manual mapping, set `disable_qubit_rewiring=True` when submitting the quantum task to run.\n",
    "\n",
    "If all the gates in the circuit satisfy the topological constraints of the device, Amazon Braket maps abstract qubit $i$ in the circuit to the physical qubit $i$ in the device, and maps qubit pair $(i, j)$ to the connection $(i, j)$ in the device. On the other hand, Amazon Braket raises an exception if a specified qubit or qubit pair do not exist in the device connectivity graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T   : │     0      │\n",
      "       ┌──────────┐ \n",
      "q0  : ─┤ Rz(1.57) ├─\n",
      "       └──────────┘ \n",
      "          ┌───┐     \n",
      "q7  : ────┤ X ├─────\n",
      "          └───┘     \n",
      "          ┌───┐     \n",
      "q17 : ────┤ X ├─────\n",
      "          └─┬─┘     \n",
      "            │       \n",
      "q24 : ──────●───────\n",
      "                    \n",
      "T   : │     0      │\n"
     ]
    }
   ],
   "source": [
    "# create a random state with neighboring qubits\n",
    "q1 = random.choice(list(connectivity_graph))\n",
    "q2 = int(connectivity_graph[q1][0])\n",
    "q1 = int(q1)\n",
    "\n",
    "circuit = Circuit()\n",
    "circuit.rz(0, np.pi / 2).cnot(q1, q2).x(7)\n",
    "print(circuit)\n",
    "rigetti_task = device.run(circuit, shots=10, disable_qubit_rewiring=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "print(\"Status of quantum task:\", rigetti_task.state())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'0001': 7, '0101': 1, '0000': 1, '0011': 1})\n",
      "The compiled circuit is:\n",
      " PRAGMA INITIAL_REWIRING \"NAIVE\"\n",
      "DECLARE ro BIT[4]\n",
      "PRAGMA PRESERVE_BLOCK\n",
      "RX(1.5707963267948966) 7\n",
      "RX(1.5707963267948966) 24\n",
      "RX(1.5707963267948966) 7\n",
      "RZ(4.71238898038469) 24\n",
      "ISWAP 24 17\n",
      "RZ(3.141592653589793) 17\n",
      "RX(1.5707963267948966) 17\n",
      "PRAGMA END_PRESERVE_BLOCK\n",
      "MEASURE 0 ro[0]\n",
      "MEASURE 7 ro[3]\n",
      "MEASURE 24 ro[1]\n",
      "MEASURE 17 ro[2]\n"
     ]
    }
   ],
   "source": [
    "result = rigetti_task.result()\n",
    "counts = result.measurement_counts\n",
    "print(\"Measurement counts:\", counts)\n",
    "print(\"The compiled circuit is:\\n\", result.additional_metadata.rigettiMetadata.compiledProgram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The qubits in the original circuit followed a one-to-one mapping to the physical qubits in the device. Other compilation steps, such as gate synthesis and circuit optimization, are still performed. These steps allow the circuit to run successfully and improve the overall fidelity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the qubits with the highest two-qubit gate fidelity\n",
    "\n",
    "Additionally, the device properties include calibration data, which you can use to find the qubits and qubit pairs with the highest fidelities for particular gates.\n",
    "\n",
    "The following function finds the qubit pair that has the highest two-qubit fidelity of an input gate, which can be any of the gates native to the Rigetti device. First, you can access the native gates as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['RX', 'RZ', 'ISWAP']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "native_gates = device.properties.paradigm.nativeGateSet\n",
    "gates_uppercase = [gate.upper() for gate in native_gates]\n",
    "gates_uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def find_qubit_pair(gate):\n",
    "    \"Function to find the qubit pair that has the highest gate fidelity of a particular gate\"\n",
    "\n",
    "    # check whether the input gate is a string\n",
    "    if not isinstance(gate, str):\n",
    "        raise ValueError(\"The input gate must be a string type.\")\n",
    "\n",
    "    # check whether the input gate is a native gate\n",
    "    gate_list = gates_uppercase\n",
    "    if gate not in gate_list:\n",
    "        raise ValueError(f\"The input gate must be one of {gates_uppercase}.\")\n",
    "\n",
    "    # load all calibration data from device.properties\n",
    "    calibration_2Q = device.properties.standardized.twoQubitProperties\n",
    "    \n",
    "    # iterate through all calibration data to find the highest fidelity\n",
    "    fidelities = []\n",
    "    for pair, entry in calibration_2Q.items():\n",
    "        for g in entry.twoQubitGateFidelity:\n",
    "            name = g.gateName\n",
    "            fidelity = g.fidelity\n",
    "            if name == gate:\n",
    "                fidelities.append((pair, fidelity))\n",
    "    (best_pair, highest_fidelity) = max(fidelities, key=lambda item: item[1])\n",
    "\n",
    "    # generate the two qubits as integers\n",
    "    q1, q2 = tuple(map(int, best_pair.split('-')))\n",
    "\n",
    "    return q1, q2, highest_fidelity\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The example in the following code applies a native two-qubit gate on the qubit pair that has the highest fidelity of that gate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The highest fidelity for ISWAP gate is: 0.9944077775042964\n",
      "And the corresponding qubit pair is: qubit 70 and qubit 77\n",
      "T   : │  0  │\n",
      "             \n",
      "q70 : ───●───\n",
      "         │   \n",
      "       ┌─┴─┐ \n",
      "q77 : ─┤ Z ├─\n",
      "       └───┘ \n",
      "T   : │  0  │\n"
     ]
    }
   ],
   "source": [
    "# the gate must be a native gate\n",
    "gate = \"ISWAP\"\n",
    "# find the qubit pair with the highest gate fidelity\n",
    "q1, q2, highest_fidelity = find_qubit_pair(gate)\n",
    "print(\"The highest fidelity for \" + gate + \" gate is:\", highest_fidelity)\n",
    "print(f\"And the corresponding qubit pair is: qubit {q1} and qubit {q2}\")\n",
    "\n",
    "# create a circuit with the gate applied to the discovered qubit pair.\n",
    "# note that CPHASE in Rigetti corresponds to cphaseshift in Braket\n",
    "circuit = Circuit()\n",
    "circuit.cz(q1, q2)\n",
    "print(circuit)\n",
    "rigetti_task = device.run(circuit, shots=100, disable_qubit_rewiring=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "print(\"Status of quantum task:\", rigetti_task.state())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The qubits in the original circuit followed a one-to-one mapping to the physical qubits in the device. Since only native gates were used, the actual gates executed are the same as the gates in the original circuit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The IonQ device does not support manual allocation. For circuits submitted to the IonQ device, qubits are allocated automatically.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{<_Rigetti.Ankaa3: 'arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3'>: {'shots': 120, 'tasks': {'COMPLETED': 2, 'QUEUED': 1}}}\n",
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 1.01 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Quantum Task Summary\")\n",
    "print(t.quantum_tasks_statistics())\n",
    "print(\n",
    "    \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n",
    ")\n",
    "print(\n",
    "    f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.2f} USD\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.10.10",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}