3.1-Transforms-Module.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "834a6a3c-5ff4-47a1-8089-e3575138a825",
   "metadata": {},
   "source": [
    "# 3.1 The transforms module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5a5c029-8cfa-43ce-9ee1-3baa525802ce",
   "metadata": {},
   "source": [
    "## 3.1.1 Single-tape and quantum function transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23c157e9-14af-4847-a9cc-12b629fbf669",
   "metadata": {},
   "source": [
    "The following single tape transform implements the circuit identity \n",
    "\n",
    "$$\n",
    "CNOT_{ij} = H_j \\cdot CZ_{ij} \\cdot H_j,\n",
    "$$ \n",
    "\n",
    "and applies it directly to a quantum tape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "924bf893-c5d9-402c-95b0-653a7618c8d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "\n",
    "@qml.single_tape_transform\n",
    "def convert_cnots(tape):\n",
    "    for op in tape:\n",
    "        if op.name == 'CNOT':\n",
    "            qml.Hadamard(wires=op.wires[1])\n",
    "            qml.CZ(wires=[op.wires[0], op.wires[1]])\n",
    "            qml.Hadamard(wires=op.wires[1])\n",
    "        else: \n",
    "            qml.apply(op)\n",
    "\n",
    "with qml.tape.QuantumTape() as tape:\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.RX(0.1, wires=0)\n",
    "    qml.CNOT(wires=[1, 2])\n",
    "    qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))\n",
    "\n",
    "transformed_tape = convert_cnots(tape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "739f463f-0e89-4154-8f60-5174cb010b8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ─╭●──RX─┤ ╭<Z@Z>\n",
      "1: ─╰X─╭●──┤ ╰<Z@Z>\n",
      "2: ────╰X──┤       \n"
     ]
    }
   ],
   "source": [
    "print(qml.drawer.tape_text(tape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7b890d93-40db-429b-96dd-dcbdbd5d9a85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: ──H─╭Z──H──╭●────┤ ╭<Z@Z>\n",
      "0: ────╰●──RX─│─────┤ ╰<Z@Z>\n",
      "2: ──H────────╰Z──H─┤       \n"
     ]
    }
   ],
   "source": [
    "print(qml.drawer.tape_text(transformed_tape))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68925ac9-8b7f-46a7-bf23-77b94b333bd0",
   "metadata": {},
   "source": [
    "A tape transform can be elevated to a quantum function transform (qfunc transform) by swapping out the top-level decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9a702993-7a4f-4363-b19a-e980ef4284fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qfunc_transform\n",
    "def convert_cnots(tape):\n",
    "    for op in tape:\n",
    "        if op.name == 'CNOT':\n",
    "            qml.Hadamard(wires=op.wires[1])\n",
    "            qml.CZ(wires=[op.wires[0], op.wires[1]])\n",
    "            qml.Hadamard(wires=op.wires[1])\n",
    "        else:\n",
    "            qml.apply(op)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf59771a-32c7-4fe3-b87c-1dce5660f798",
   "metadata": {},
   "source": [
    "Once defined, qfunc transforms can be applied to quantum functions as a decorator. This enables us to easily compose qfunc transforms by stacking decorators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4abec5fb-3815-42d5-bd3f-159f5d8d90d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=3)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "@convert_cnots\n",
    "def circuit(param):\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.RX(param, wires=0)\n",
    "    qml.CNOT(wires=[1, 2])\n",
    "    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f623ac17-fe5d-46f6-b78c-7071c661c7c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.87758256, requires_grad=True)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "53f102e6-203b-41a5-874c-eb53ce06e39d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ────╭●──RX(0.30)───────┤ ╭<Z@Z>\n",
      "1: ──H─╰Z──H────────╭●────┤ ╰<Z@Z>\n",
      "2: ──H──────────────╰Z──H─┤       \n"
     ]
    }
   ],
   "source": [
    "print(qml.draw(circuit)(0.3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f206543-ec32-4512-975b-6a7f7cf63b9f",
   "metadata": {},
   "source": [
    "We can apply classical processing to a tape's parameters in a way that preserves their differentiability. This can be done in a framework-agnostic way using the `qml.math` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "24be1355-f238-4993-a05a-32d7d80b9a63",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane.math as math\n",
    "\n",
    "@qml.qfunc_transform\n",
    "def square_root_rx(tape):\n",
    "    for op in tape:\n",
    "        if op.name == 'RX':\n",
    "            # Modify each RX gate to apply sqrt of rotation angle\n",
    "            qml.RX(math.sqrt(op.data[0]), wires=op.wires[0])\n",
    "        else :\n",
    "            qml.apply(op)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e873d8c-0337-4efd-a63e-4c4dde2ba493",
   "metadata": {},
   "source": [
    "Below is an example of this using the PyTorch framework."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f7d06df5-a711-4bb0-8592-6e99c4053003",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "def apply_rx(x):\n",
    "    qml.RX(x, wires=0)\n",
    "    return qml.expval(qml.PauliZ(0))\n",
    "\n",
    "dev = qml.device('default.qubit', wires=1)\n",
    "\n",
    "# Create a QNode with the untransformed function and compute the gradient\n",
    "qnode = qml.QNode(apply_rx, dev, interface='torch')\n",
    "\n",
    "x_orig = torch.tensor(0.3, requires_grad=True)\n",
    "res = qnode(x_orig)\n",
    "res.backward()\n",
    "\n",
    "# Create a QNode with the transformed function and again compute the gradient\n",
    "transformed_qnode = qml.QNode(square_root_rx(apply_rx), dev, interface='torch')\n",
    "\n",
    "x_transformed = torch.tensor(0.3, requires_grad=True)\n",
    "res = transformed_qnode(x_transformed)\n",
    "res.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50baf5f7-7e9e-483d-a2ca-d8f364a7fc24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(-0.2955)\n"
     ]
    }
   ],
   "source": [
    "print(x_orig.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b4974884-34ee-4316-8fbc-4d94a1a156ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(-0.4754)\n"
     ]
    }
   ],
   "source": [
    "print(x_transformed.grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2ba8f1-ab05-41a4-8dce-8bf7a5d9a5c3",
   "metadata": {},
   "source": [
    "## 3.1.2 Batch transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c25142-743d-4b5d-b79d-10998e1487b6",
   "metadata": {},
   "source": [
    "We construct a Hamiltonian and tape as per Figure 4, taking $c_1 = c_2 = c_3 = 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0de33697-ce59-4417-8613-2f09af1bdcd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PennyLane has a built-in NumPy that has been adjusted to work with\n",
    "# automatic differentation.\n",
    "from pennylane import numpy as np\n",
    "\n",
    "coeffs = np.array([1, 1, 1])\n",
    "obs = [\n",
    "    qml.PauliZ(0) @ qml.PauliZ(1), \n",
    "    qml.PauliY(0) @ qml.PauliY(1), \n",
    "    qml.PauliX(0) @ qml.PauliX(1)\n",
    "]\n",
    "\n",
    "H = qml.Hamiltonian(coeffs, obs)\n",
    "\n",
    "with qml.tape.QuantumTape() as tape:\n",
    "    qml.RY(0.3, wires=0)\n",
    "    qml.RY(0.4, wires=1)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.CNOT(wires=[1, 0])\n",
    "    qml.expval(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24413c5f-8faf-410c-81c5-db54ea6edc83",
   "metadata": {},
   "source": [
    "Applying the `hamiltonian_expand` transform gives us back a list of tapes, and a processing function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6f94beac-9797-4c53-a042-872b49e43d4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "tapes, fn = qml.transforms.hamiltonian_expand(tape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c517f5f6-ef8c-4d9c-8157-70dd4b580d94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ──RY─╭●─╭X─┤ ╭<Z@Z>\n",
      "1: ──RY─╰X─╰●─┤ ╰<Z@Z>\n",
      "\n",
      "0: ──RY─╭●─╭X─┤ ╭<Y@Y>\n",
      "1: ──RY─╰X─╰●─┤ ╰<Y@Y>\n",
      "\n",
      "0: ──RY─╭●─╭X─┤ ╭<X@X>\n",
      "1: ──RY─╰X─╰●─┤ ╰<X@X>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for t in tapes:\n",
    "    print(qml.drawer.tape_text(t), end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2984bcb-766b-4884-88eb-3540d20b15d2",
   "metadata": {},
   "source": [
    "Note that we have one tape per observable. Let's now create a device, and execute the tapes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c26021bc-71e1-4501-9b8f-43f1d4c5de22",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=2)\n",
    "results = qml.execute(tapes, dev, gradient_fn=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d04c6c51-39e4-4f98-8144-7f32f4769502",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.8537, dtype=torch.float64, grad_fn=<SqueezeBackward0>)\n"
     ]
    }
   ],
   "source": [
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3afde452-0df4-4642-86f5-8aa04a0e3295",
   "metadata": {},
   "source": [
    "The processing function `fn` can now be applied to these results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c76259fc-3c2a-4b87-a72a-4f710941d041",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(0.97272928)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "738fbf84-1bce-463a-84d5-d46b8e6331bb",
   "metadata": {},
   "source": [
    "## 3.1.3 Other transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbc997e5-91fb-4690-9b9f-e09d3e9cf941",
   "metadata": {},
   "source": [
    "Two other types of transforms exist in PennyLane: device transforms, and information transforms. An example below is show for a device transform that applies amplitude damping after every gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a9576edc-746b-4e1c-8d51-582edf71b544",
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit(x):\n",
    "    qml.RX(-2*x, wires=0)\n",
    "    qml.S(wires=0)    \n",
    "    return qml.probs(wires=0)\n",
    "\n",
    "dev = qml.device('default.mixed', wires=1)\n",
    "qnode = qml.QNode(circuit, dev)\n",
    "\n",
    "# Adds amplitude damping after every gate at the device level\n",
    "noisy_dev = qml.transforms.insert(qml.AmplitudeDamping, 0.05, position=\"all\")(dev)\n",
    "\n",
    "# Create a QNode on the transformed device\n",
    "noisy_qnode = qml.QNode(circuit, noisy_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa54fca7-6f4d-4a58-a5c4-79054ece85fd",
   "metadata": {},
   "source": [
    "An example of an information transform is `qml.draw`. It takes a QNode as input and return a function that draws it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9295c0f9-fc10-4db6-ba44-031affc09995",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ──RX(-0.60)──S─┤  Probs\n"
     ]
    }
   ],
   "source": [
    "print(qml.draw(qnode, expansion_strategy=\"device\")(0.3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b990e1a0-3eeb-45a1-a965-6101e6f083db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ──RX(-0.60)──AmplitudeDamping(0.05)──S──AmplitudeDamping(0.05)─┤  Probs\n"
     ]
    }
   ],
   "source": [
    "print(qml.draw(noisy_qnode, expansion_strategy=\"device\")(0.3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1a04376-cf45-4fa2-bfff-d36530f82ffc",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}