circuit_generator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit import *\n",
    "%matplotlib inline\n",
    "from qiskit.visualization import plot_histogram\n",
    "from qiskit.tools.visualization import circuit_drawer\n",
    "from qiskit.circuit import Gate\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def apply_gate(circuit,gate_str,applied,ctrl=0):\n",
    "    if gate_str == 'H':\n",
    "        circuit.h(applied)\n",
    "    elif gate_str == 'HZ':\n",
    "        circuit.z(applied)\n",
    "        circuit.h(applied)\n",
    "    elif gate_str == 'X':\n",
    "        circuit.x(applied)\n",
    "    elif gate_str == 'Z':\n",
    "        circuit.z(applied)\n",
    "    elif gate_str == 'CX':\n",
    "        circuit.cx(ctrl,applied)\n",
    "    elif gate_str == 'I':\n",
    "        pass\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_subcircuit(no_qubits):\n",
    "    gates_lists = ['H', 'HZ', 'X', 'Z', 'CX'] + 3*['I']\n",
    "    circuit = QuantumCircuit(no_qubits)\n",
    "    for q in range(no_qubits):\n",
    "        gate = np.random.choice(gates_lists)\n",
    "        ctrl = 0\n",
    "        if gate == 'CX':\n",
    "            list_qubits = list(range(no_qubits))\n",
    "            list_qubits.pop(q)\n",
    "            ctrl = np.random.choice(list_qubits)\n",
    "        apply_gate(circuit, gate, q, ctrl)\n",
    "    circuit.barrier()\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐ ░ \n",
       "q_0: |0>┤ H ├─░─\n",
       "        └───┘ ░ \n",
       "q_1: |0>──────░─\n",
       "              ░ </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x11bd85080>"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit = generate_subcircuit(2)\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_game(no_qubits, no_rounds):\n",
    "    Circuits = []\n",
    "    Plays = []\n",
    "    \n",
    "    init_circuit = QuantumCircuit(no_qubits)\n",
    "    init_circuit.h(range(no_qubits))\n",
    "    init_circuit.barrier()\n",
    "    Circuits.append(init_circuit)\n",
    "    \n",
    "    for n in range(no_rounds):\n",
    "        qubits_play = np.random.choice(list(range(no_qubits)),2,replace = False)\n",
    "        np.random.shuffle(qubits_play)\n",
    "        play = [('P0',qubits_play[0]), ('P1',qubits_play[1])]      \n",
    "        Plays.append(play)\n",
    "        Circuits.append(generate_subcircuit(no_qubits))\n",
    "        \n",
    "    return Circuits, Plays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_game(Circuits, Plays):\n",
    "    final_circ = Circuits[0].copy()\n",
    "    for play, circ in zip(Plays, Circuits[1:]):\n",
    "        for player, qubit in play:\n",
    "            if player in ['P0','P1']:\n",
    "                final_circ.append(Gate(name = player, num_qubits = 1, params = []),[qubit])\n",
    "            else:\n",
    "                final_circ = apply_gate(final_circ,gate_str = player,applied = qubit)\n",
    "        final_circ.barrier()\n",
    "        final_circ = final_circ + circ\n",
    "        final_circ.measure()\n",
    "    final_circ.draw(output = 'mpl').savefig('stage.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distribute_cards(no_rounds):\n",
    "    cards_list = ['H', 'HZ', 'X', 'Z', 'I']\n",
    "    deck = np.array(no_rounds*cards_list)\n",
    "    np.random.shuffle(deck)\n",
    "    hand_size = no_rounds + 1\n",
    "    hand_P0 = dict(Counter(deck[0:hand_size]))\n",
    "    hand_P1 = dict(Counter(deck[hand_size:2*hand_size]))\n",
    "    return hand_P0, hand_P1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐ ░ ┌───┐ ░  ░ ┌────┐ ░            ░ \n",
      "q_0: |0>┤ H ├─░─┤ H ├─░──░─┤ P1 ├─░────────────░─\n",
      "        ├───┤ ░ ├───┤ ░  ░ ├────┤ ░ ┌───┐┌───┐ ░ \n",
      "q_1: |0>┤ H ├─░─┤ X ├─░──░─┤ P0 ├─░─┤ Z ├┤ H ├─░─\n",
      "        └───┘ ░ └───┘ ░  ░ └────┘ ░ └───┘└───┘ ░ \n"
     ]
    }
   ],
   "source": [
    "Circuits, Plays = generate_game(2,2)\n",
    "Plays[0] = [('X',1),('H',0)]\n",
    "draw_game(Circuits, Plays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[('Z', 1), ('X', 0)], [('P0', 1), ('P1', 0)]]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_round(n_round,Plays,P0,P1):\n",
    "    Plays[n_round][0] = (P0, Plays[n_round][0][1])\n",
    "    Plays[n_round][1] = (P1, Plays[n_round][1][1])\n",
    "    return Plays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_played_game(Circuits, Plays):\n",
    "    final_circ = Circuits[0].copy()\n",
    "    print(final_circ.draw())\n",
    "    for play, circ in zip(Plays, Circuits[1:]):\n",
    "        for player, qubit in play:\n",
    "            if player in ['P0','P1']:\n",
    "                return final_circ\n",
    "            else:\n",
    "                final_circ = apply_gate(final_circ, gate_str = player,applied = qubit)         \n",
    "        final_circ.barrier()\n",
    "        final_circ = final_circ + circ\n",
    "    return final_circ\n",
    "\n",
    "# def get_played_game(Circuits, Plays):\n",
    "#     final_circ = Circuits[0].copy()\n",
    "#     print(final_circ.draw())\n",
    "#     for play, circ in zip(Plays, Circuits[1:]):\n",
    "#         for player, qubit in play:\n",
    "#             if player in ['P0','P1']:\n",
    "#                 return final_circ\n",
    "#             else:\n",
    "#                 final_circ = apply_gate(final_circ, gate_str = player,applied = qubit)         \n",
    "#         final_circ.barrier()\n",
    "#         final_circ = final_circ + circ\n",
    "#     return final_circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐ ░ ┌───┐ ░ \n",
      "q_0: |0>┤ H ├─░─┤ H ├─░─\n",
      "        ├───┤ ░ ├───┤ ░ \n",
      "q_1: |0>┤ H ├─░─┤ X ├─░─\n",
      "        └───┘ ░ └───┘ ░ \n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐ ░ ┌───┐ ░ ┌───┐ ░  ░ \n",
       "q_0: |0>┤ H ├─░─┤ H ├─░─┤ H ├─░──░─\n",
       "        ├───┤ ░ ├───┤ ░ ├───┤ ░  ░ \n",
       "q_1: |0>┤ H ├─░─┤ X ├─░─┤ X ├─░──░─\n",
       "        └───┘ ░ └───┘ ░ └───┘ ░  ░ </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x10c0bce10>"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "partial_circ = get_played_game(Circuits, Plays)\n",
    "partial_circ.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_state(partial_circuit):\n",
    "    backend = Aer.get_backend('statevector_simulator')\n",
    "    job = execute(partial_circ, backend)\n",
    "    result = job.result()\n",
    "    state = result.get_statevector(partial_circ, decimals=3)\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score_counts(state_v):\n",
    "    e_ones = 0\n",
    "    for i, p in enumerate(np.abs(state_v)**2):\n",
    "        e_ones += p*np.sum(np.array(list(bin(i)[2:])).astype(np.int))\n",
    "    return np.around(e_ones/np.log2(len(state_v))*100,decimals = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace_distance(A,B):\n",
    "    X = A-B\n",
    "    evals = np.linalg.eigvals(X)\n",
    "    return 0.5*np.sum(np.abs(evals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score_tr_dist(state_v):\n",
    "    rho = np.tensordot(state_v, state_v.conj(), axes = 0)\n",
    "    rho_1 = np.zeros_like(rho)\n",
    "    rho_1[-1,-1] = 1\n",
    "    return trace_distance(rho, rho_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#score_tr_dist(np.array([0.25,0.25,0.25,0.25]))\n",
    "score_tr_dist(np.array([0,np.sqrt(0.5),np.sqrt(0.5),0]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}