circuit_generatorV2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit import *\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\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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",
    "        circuit.iden(applied)\n",
    "    elif gate_str == 'Id':\n",
    "        pass\n",
    "    return circuit\n",
    "\n",
    "\n",
    "def generate_subcircuit(no_qubits):\n",
    "    gates_lists = ['H', 'HZ', 'X', 'Z', 'CX'] + 3*['Id']\n",
    "    circuit = QuantumCircuit(no_qubits)\n",
    "    all_ids = True\n",
    "    for q in range(no_qubits):\n",
    "        gate = np.random.choice(gates_lists)\n",
    "        if gate != 'Id':\n",
    "            all_ids = False\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",
    "    if not all_ids:\n",
    "        circuit.barrier()\n",
    "    return circuit\n",
    "\n",
    "#------------------------------------------------------------------------------\n",
    "#main functions\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "def draw_game(Circuits, Plays, unveil = False):\n",
    "    final_circ = Circuits[0].copy()\n",
    "    FLAG = False\n",
    "    for play, circ in zip(Plays, Circuits[1:]):\n",
    "        for player, qubit in play:\n",
    "            if player in ['P0','P1']:\n",
    "                FLAG = True\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",
    "        if unveil and FLAG:\n",
    "            for q in range(circ.n_qubits):\n",
    "                final_circ.append(Gate(name = '?', num_qubits = 1, params = []),[q])\n",
    "            final_circ.barrier()\n",
    "        else:\n",
    "            final_circ = final_circ + circ\n",
    "        #final_circ.measure()\n",
    "    final_circ.draw(output = 'mpl').savefig('stage2.png')\n",
    "\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "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\n",
    "\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\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def compute_state(partial_circ):\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\n",
    "\n",
    "\n",
    "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)\n",
    "\n",
    "\n",
    "def state_draw(state):\n",
    "    dict = {}\n",
    "    state = list(state)\n",
    "    tmp = int(math.log(len(state),2))\n",
    "    for i in range(len(state)):\n",
    "        dict[str(bin(i)[2:].zfill(tmp))] = 1000*np.abs(state[i])**2\n",
    "    plot_histogram(dict).savefig(\"state_prb.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "Circuits, Plays = generate_game(3,4)\n",
    "Plays = play_round(0, Plays, 'X', 'HZ')\n",
    "draw_game(Circuits, Plays, unveil = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Circuits[0].n_qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('P0', 2), ('P1', 0)]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plays[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}