examples/braket_features/Simulating_Advanced_OpenQASM_Programs_with_the_Local_Simulator.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c7af4e38",
   "metadata": {},
   "source": [
    "# Simulating Advanced OpenQASM Programs with the Local Simulator\n",
    "\n",
    "The `LocalSimulator` now supports simulating OpenQASM programs and the scope\n",
    "of supported language features is larger than previously offered on Braket!\n",
    "\n",
    "This notebook serves as a references of all OpenQASM features supported by Braket\n",
    "with the `LocalSimulator`. For detailed documentation about the language, see the [OpenQASM 3.0 specification](https://openqasm.com/language/index.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b7b66af",
   "metadata": {},
   "source": [
    "## Creating the Device\n",
    "\n",
    "We create the device using the LocalSimulator class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "06a7dd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "from braket.devices import LocalSimulator\n",
    "\n",
    "device = LocalSimulator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a472ce2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# to make the output a little neater\n",
    "\n",
    "import numpy as np\n",
    "np.set_printoptions(precision=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c86bc9b",
   "metadata": {},
   "source": [
    "## Run a Bell circuit\n",
    "\n",
    "Let's do a Hello World example where we run a Bell circuit!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ddc46f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'11': 56, '00': 44})\n"
     ]
    }
   ],
   "source": [
    "from braket.ir.openqasm import Program\n",
    "\n",
    "qasm_string = \"\"\"\n",
    "qubit[2] q;\n",
    "\n",
    "h q[0];\n",
    "cnot q[0], q[1];\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb1d7a0b",
   "metadata": {},
   "source": [
    "## Run a Bell circuit with a result type\n",
    "\n",
    "Let's run the same circuit, but with no shots, instead getting the\n",
    "state vector.\n",
    "\n",
    "For more info on supported result types, see the [developer guide](https://docs.aws.amazon.com/braket/latest/developerguide/braket-openqasm-supported-features.html#braket-openqasm-supported-features-pragmas)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "28094ca2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State vector result: [0.707+0.j 0.   +0.j 0.   +0.j 0.707+0.j]\n"
     ]
    }
   ],
   "source": [
    "from braket.ir.openqasm import Program\n",
    "\n",
    "qasm_string = \"\"\"\n",
    "qubit[2] q;\n",
    "\n",
    "h q[0];\n",
    "cnot q[0], q[1];\n",
    "\n",
    "#pragma braket result state_vector\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program).result()\n",
    "print(f\"State vector result: {result.result_types[0].value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d04fa192",
   "metadata": {},
   "source": [
    "## Gate Modifiers\n",
    "\n",
    "You can use the following gate modifiers on any gate: `inv`, `ctrl`, `negctrl`, `pow`.\n",
    "\n",
    "For more documentation on gate modifiers, see the [OpenQASM specification](https://openqasm.com/language/gates.html#quantum-gate-modifiers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a99ad362",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'00': 54, '11': 46})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit[2] q;\n",
    "\n",
    "h q[0];\n",
    "ctrl @ x q[0], q[1];\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bdcf62df",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State vector result: [1.+0.j 0.+0.j]\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit q;\n",
    "\n",
    "pow(1/2) @ x q;     // sqrt x\n",
    "inv @ v q;          // inv of (sqrt x)\n",
    "\n",
    "#pragma braket result state_vector\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=0).result()\n",
    "print(f\"State vector result: {result.result_types[0].value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77cf185c",
   "metadata": {},
   "source": [
    "## OpenQASM Built-in Gates\n",
    "\n",
    "You can use the built-in OpenQASM quantum directives, the parameterized unitary, `U`,\n",
    "and the global phase instruction `gphase`.\n",
    "\n",
    "For more info on the built-in quantum operations, see the [OpenQASM specification](https://openqasm.com/language/gates.html#built-in-gates)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6ceaa1f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State vector result: [6.123e-17+0.j 1.000e+00+0.j]\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit q;\n",
    "\n",
    "U(π, 0, π) q;\n",
    "\n",
    "#pragma braket result state_vector\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=0).result()\n",
    "print(f\"State vector result: {result.result_types[0].value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14221b8d",
   "metadata": {},
   "source": [
    "## Classical Variables\n",
    "\n",
    "The `LocalSimulator` supports OpenQASM variables and constants of the\n",
    "following types: `int`, `uint`, `float`, `bool`, `bit`.\n",
    "\n",
    "For more info on classical variables in OpenQASM, see the [OpenQASM specification](https://openqasm.com/language/types.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "84cdc765",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State vector result: [1.+0.j 0.+0.j]\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit q;\n",
    "\n",
    "int p1 = 2;\n",
    "float p2 = .25;\n",
    "\n",
    "pow(p1) @ pow(p2) @ x q;    // sqrt x\n",
    "inv @ v q;                  // inv of (sqrt x)\n",
    "\n",
    "#pragma braket result state_vector\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=0).result()\n",
    "print(f\"State vector result: {result.result_types[0].value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180e2ebf",
   "metadata": {},
   "source": [
    "## Classical Operations\n",
    "\n",
    "You can use many standard operators on classical variables of different\n",
    "types. There is also a list of built-in functions.\n",
    "\n",
    "For a full list of supported operations and functions, see the OpenQASM specification for [classical operations](https://openqasm.com/language/classical.html) and [built-in functions](https://openqasm.com/language/types.html#mathematical-functions-available-for-constant-initialization)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ed87845",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State vector result: [0.915-0.279j 0.085+0.279j]\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit q;\n",
    "\n",
    "int p1 = floor(log(sin(20)));\n",
    "float p2 = 4 * (π/3);\n",
    "\n",
    "pow(p1) @ pow(p2) @ x q;\n",
    "\n",
    "#pragma braket result state_vector\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=0).result()\n",
    "print(f\"State vector result: {result.result_types[0].value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edecaece",
   "metadata": {},
   "source": [
    "## Custom Gates\n",
    "\n",
    "You can define your own gates using built-in Braket and OpenQASM gates, as well as other\n",
    "custom defined gates.\n",
    "\n",
    "For more information around defining custom gates, see the [OpenQASM specification](https://openqasm.com/language/gates.html#hierarchically-defined-unitary-gates)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f3a7267f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'111': 100})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit[3] q;\n",
    "\n",
    "gate majority a, b, c {\n",
    "    // set c to the majority of {a, b, c}\n",
    "    ctrl @ x c, b;\n",
    "    ctrl @ x c, a;\n",
    "    ctrl(2) @ x a, b, c;\n",
    "}\n",
    "\n",
    "x q[0:1];\n",
    "// this should flip q[2] to 1\n",
    "majority q[0], q[1], q[2];\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12ac13f7",
   "metadata": {},
   "source": [
    "## Classical control\n",
    "\n",
    "The `LocalSimulator` supports the following classical control directives:\n",
    "`if`, `for`, `while`, as well as simple subroutines (more on that later)\n",
    "\n",
    "For more info on classical control, see the [OpenQASM specification](https://openqasm.com/language/classical.html#looping-and-branching)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e30296b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'10': 100})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit[2] q;\n",
    "\n",
    "bit[2] bitstring = \"10\";\n",
    "\n",
    "for int i in [0:1] {\n",
    "    if (bitstring[i]) {\n",
    "        x q[i];\n",
    "    }\n",
    "    else {\n",
    "        i q[i];\n",
    "    }\n",
    "}\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c2c5c4b",
   "metadata": {},
   "source": [
    "## Input\n",
    "\n",
    "The `LocalSimulator` supports parametric circuits using the `input` directive allowing users\n",
    "to provide a dictionary to the `inputs` field in the OpenQASM Program object.\n",
    "\n",
    "For documentation on the input directive, see the [OpenQASM specification](https://openqasm.com/language/directives.html#input-output)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "61be5288",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'0': 78, '1': 22})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "input float theta;\n",
    "qubit q;\n",
    "rx(theta) q;\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string, inputs={\"theta\": 1.0})\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2be09a4d",
   "metadata": {},
   "source": [
    "## QASM Files\n",
    "\n",
    "Instead of providing an OpenQASM string, you can provide a filename."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "86660631",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 + 11 = 13\n"
     ]
    }
   ],
   "source": [
    "a_in, b_in = 2, 11\n",
    "inputs = {\"a_in\": a_in, \"b_in\": b_in}\n",
    "\n",
    "program = Program(source=\"adder.qasm\", inputs=inputs)\n",
    "device = LocalSimulator()\n",
    "\n",
    "result = device.run(program).result()\n",
    "probs = np.outer(\n",
    "    result.result_types[0].value,\n",
    "    result.result_types[1].value\n",
    ").flatten()\n",
    "answer = np.argmax(probs)\n",
    "print(f\"{a_in} + {b_in} = {answer}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44dea89e",
   "metadata": {},
   "source": [
    "## Subroutines\n",
    "\n",
    "The `LocalSimulator` supports creating subroutines to compartmentalize pieces of your code.\n",
    "They can support both classical and quantum computation. Note that  using variables that are in scope during\n",
    "subroutine definition, but not passed as arguments is currently undefined behavior.\n",
    "\n",
    "For documentation around subroutines, see the [OpenQASM specification](https://openqasm.com/language/subroutines.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "324e28a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'1': 100})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "const int[8] n = 4;\n",
    "input bit[n] x;\n",
    "\n",
    "qubit q;\n",
    "\n",
    "def parity(bit[n] cin) -> bit {\n",
    "  bit c = false;\n",
    "  for int[8] i in [0: n - 1] {\n",
    "    c ^= cin[i];\n",
    "  }\n",
    "  return c;\n",
    "}\n",
    "\n",
    "if(parity(x)) {\n",
    "    x q;\n",
    "} else {\n",
    "    i q;\n",
    "}\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string, inputs={\"x\": \"1011\"})\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "40e7c8c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'0': 80, '1': 20})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit q;\n",
    "\n",
    "def sum(const array[int[8], #dim = 1] arr) -> int {\n",
    "    int size = sizeof(arr);\n",
    "    int x = 0;\n",
    "    for int i in [0:size - 1] {\n",
    "        x += arr[i];\n",
    "    }\n",
    "    return x;\n",
    "}\n",
    "\n",
    "array[int, 10] arr = {9, 3, 6, 2, 2, 4, 3, 1, 12, 7};\n",
    "int s = sum(arr);\n",
    "rx(s*π/4) q;\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string)\n",
    "\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d86038",
   "metadata": {},
   "source": [
    "## Simulating Noise\n",
    "\n",
    "You can simulate noise instructions on the density matrix simulator using\n",
    "Braket noise pragmas.\n",
    "\n",
    "For more documentation around supported noise operations, see the [developer guide](https://docs.aws.amazon.com/braket/latest/developerguide/braket-openqasm-noise-simulation.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2a51dd4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurement counts: Counter({'1': 92, '0': 8})\n"
     ]
    }
   ],
   "source": [
    "qasm_string = \"\"\"\n",
    "qubit q;\n",
    "\n",
    "x q;\n",
    "\n",
    "#pragma braket noise bit_flip(.1) q\n",
    "\"\"\"\n",
    "qasm_program = Program(source=qasm_string, inputs={\"x\": \"1011\"})\n",
    "\n",
    "device = LocalSimulator(\"braket_dm\")\n",
    "result = device.run(qasm_program, shots=100).result()\n",
    "print(f\"Measurement counts: {result.measurement_counts}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_braket",
   "language": "python",
   "name": "conda_braket"
  },
  "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.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}