qgan+swap_mixed.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "def real(angles, **kwargs):\n",
    "    qml.Hadamard(wires=0)\n",
    "    qml.RY(np.pi / 6, wires=1)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.Rot(*angles, wires=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(w, **kwargs):\n",
    "    qml.Hadamard(wires=2)\n",
    "    qml.RX(w[0], wires=2)\n",
    "    qml.RX(w[1], wires=3)\n",
    "    qml.RY(w[2], wires=2)\n",
    "    qml.RY(w[3], wires=3)\n",
    "    qml.RZ(w[4], wires=2)\n",
    "    qml.RZ(w[5], wires=3)\n",
    "    qml.CNOT(wires=[2, 3])\n",
    "    qml.RX(w[6], wires=2)\n",
    "    qml.RY(w[7], wires=2)\n",
    "    qml.RZ(w[8], wires=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "def swap_test():\n",
    "    qml.Hadamard(wires=4)\n",
    "    qml.CSWAP(wires=[4, 0, 2])\n",
    "    qml.Hadamard(wires=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def overlap(phi, theta, omega, gen_weights):\n",
    "    real([phi, theta, omega])\n",
    "    generator(gen_weights)\n",
    "    swap_test()\n",
    "    return qml.expval(qml.PauliZ(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi = np.pi / 6\n",
    "theta = np.pi / 2\n",
    "omega = np.pi / 7\n",
    "np.random.seed(0)\n",
    "eps = 1e-2\n",
    "init_gen_weights = np.array([np.pi] + [0] * 8) + \\\n",
    "                   np.random.normal(scale=eps, size=(9,))\n",
    "\n",
    "gen_weights = tf.Variable(init_gen_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = tf.keras.optimizers.SGD(0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0: cost = 0.47903778021552934\n",
      "Step 5: cost = 0.38517746997223345\n",
      "Step 10: cost = 0.3161302288548482\n",
      "Step 15: cost = 0.27869552611104986\n",
      "Step 20: cost = 0.26216292759087967\n",
      "Step 25: cost = 0.25529962583341426\n",
      "Step 30: cost = 0.2523962691481132\n",
      "Step 35: cost = 0.25111593770595764\n",
      "Step 40: cost = 0.2505299313354066\n",
      "Step 45: cost = 0.25025464969337974\n"
     ]
    }
   ],
   "source": [
    "cost = lambda: 1 - overlap(phi, theta, omega, gen_weights)\n",
    "for step in range(50):\n",
    "    opt.minimize(cost, gen_weights)\n",
    "    if step % 5 == 0:\n",
    "        cost_val = cost().numpy()\n",
    "        print(\"Step {}: cost = {}\".format(step, cost_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real Bloch vector: [-0.10847093  0.22524222 -0.4330127 ]\n",
      "Generator Bloch vector: [-0.19959091  0.44361004 -0.87328997]\n"
     ]
    }
   ],
   "source": [
    "obs_real = [qml.PauliX(0), qml.PauliY(0), qml.PauliZ(0)]\n",
    "obs_gen = [qml.PauliX(2), qml.PauliY(2), qml.PauliZ(2)]\n",
    "\n",
    "bloch_vector_real = qml.map(real, obs_real, dev, interface=\"tf\")\n",
    "bloch_vector_generator = qml.map(generator, obs_gen, dev, interface=\"tf\")\n",
    "\n",
    "print(\"Real Bloch vector: {}\".format(bloch_vector_real([phi, theta, omega])))\n",
    "print(\"Generator Bloch vector: {}\".format(bloch_vector_generator(gen_weights)))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit",
   "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.8.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}