QuantumSynth.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Synth: a quantum-computer-based music synthesizer #\n",
    "\n",
    "## Omar Costa Hamido, Mohammad Ghazi Vakili, Edoardo Giusto, Alberto Baiardi, Giovanni Amedeo Cirillo ##\n",
    "### Qiskit Camp Europe, 9/13-14/2019 ###\n",
    "\n",
    "We developed an infrastructure that permits to interface Qiskit with Max, a visual programming language for music and multimedia. Notes are encoded onto the basis states of a quantum computer, so that the musician can send commands for generating superposition of notes which must be interpreted as superposition of basis states. The results provided by the quantum computer simulator or the real device are sent back to Max, thus permitting their processing for generating sounds. Some quantum circuits have been characterized in terms of sound and a demonstration of a \"phonic\" interpretation of the Grover's search algorithm is also reported.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "import numpy as np\n",
    "import operator\n",
    "import socket\n",
    "import argparse\n",
    "import random\n",
    "import time\n",
    "import logging\n",
    "from backends_select import ChooseBackEnd\n",
    "from SuperpositionGates import *\n",
    "from RenormalizeProbability import *\n",
    "\n",
    "from pythonosc import udp_client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "UDP_IP_SERVER=\"127.0.0.1\"#change this accordingly\n",
    "UDP_PORT_SERVER=7001\n",
    "\n",
    "# global functions\n",
    "log = logging.getLogger('udp_server')\n",
    "\n",
    "\n",
    "\n",
    "def sender(results,name):\n",
    "    parser = argparse.ArgumentParser()\n",
    "    parser.add_argument(\"--ip\", default=UDP_IP_SERVER,\n",
    "      help=\"The ip of the OSC server\")\n",
    "    parser.add_argument(\"--port\", type=int, default=7000,\n",
    "      help=\"The port the OSC server is listening on\")\n",
    "    args = parser.parse_args()\n",
    "\n",
    "    client = udp_client.SimpleUDPClient(args.ip, args.port)\n",
    "    # for k in sorted(results):\n",
    "    #     print(k, results[k])\n",
    "    #     client.send_message(k, results[k])\n",
    "    client.send_message(name, results)\n",
    "    return True\n",
    "\n",
    "\n",
    "def server(host='0.0.0.0', port=UDP_PORT_SERVER):\n",
    "    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n",
    "    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n",
    "\n",
    "    log.info(\"Listening on udp %s:%s\" % (host, port))\n",
    "    s.bind((host, port))\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Qiskit-Max communication for the implemented quantum gates ##\n",
    " \n",
    "In the following you can find the functions permitting the communication between Qiskit and Max. It is important to precise that the result of Qiskit are provided to Max as a string of type $P_{0000} P_{0001} ... P_{1111}$ or $P_{0000} P_{0001} ... P_{1011}$ (according to the type of synthesis: additive or subtractive), where the probabilities of each basis state are separated by a space. For further details of the implemented quantum circuits, please look at the GatesNotebook Jupyter Notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-09-14 11:46:24,502 udp_server       INFO\tListening on udp 0.0.0.0:7001\n"
     ]
    }
   ],
   "source": [
    "def grover4(target, backendType, RealDeviceName,noisePresent=False,number=12):\n",
    "    listForMusic = GroverSequence(target=target, initialLength=4, backendType=backendType, RealDeviceName=RealDeviceName, noisePresent=noisePresent)\n",
    "\n",
    "    message = \"\"\n",
    "    for k in listForMusic:\n",
    "        # ii = 0\n",
    "        print(k)\n",
    "        if number== 12:\n",
    "            k=RedistributeCell(k)\n",
    "        print(k)\n",
    "        for l in k:\n",
    "            message = message + str(l) + \" \"\n",
    "            # ii = ii + 1\n",
    "            # if ii == 12:\n",
    "            #     print(ii)\n",
    "            #     break\n",
    "    print(message)\n",
    "    sender(results=message, name=\"grover\")\n",
    "\n",
    "def hadamard(backendType, RealDeviceName, noisePresent,numberShots,number=12):\n",
    "    circuit=QuantumCircuit(4,4)\n",
    "    Hadamard(circuit, listOfQubits=range(4))\n",
    "    listForMusic = ChooseBackEnd(circuit, backendType=backendType, qubitsToBeMeasured=range(4), numberShots=numberShots, noisePresent=noisePresent, RealDeviceName=RealDeviceName,number=number)\n",
    "    print(listForMusic)\n",
    "\n",
    "    if number==12:\n",
    "        listForMusic = RedistributeCell(listForMusic)\n",
    "\n",
    "    print(listForMusic)\n",
    "    sender(results=listForMusic, name=\"prob\")\n",
    "\n",
    "    del(circuit)\n",
    "\n",
    "def Bell(backendType, RealDeviceName, noisePresent,numberShots,number=12):\n",
    "    circuit=QuantumCircuit(4,4)\n",
    "    BellStateGenerationTwoQubits(circuit)\n",
    "    listForMusic = ChooseBackEnd(circuit, backendType=backendType, qubitsToBeMeasured=range(4), numberShots=numberShots, noisePresent=noisePresent, RealDeviceName=RealDeviceName)\n",
    "    print(listForMusic)\n",
    "    if number==12:\n",
    "        listForMusic = RedistributeCell(listForMusic)\n",
    "    print(listForMusic)\n",
    "    sender(results=listForMusic, name=\"prob\")\n",
    "    del(circuit)\n",
    "\n",
    "def SeperPosition(backendType, RealDeviceName, noisePresent,numberShots,number=12,notes=range(4)):\n",
    "    circuit=QuantumCircuit(4,4)\n",
    "    ChooseEqualSuperposition(circuit,states=notes)#we have to check togather\n",
    "    listForMusic = ChooseBackEnd(circuit, backendType=backendType, qubitsToBeMeasured=range(4), numberShots=numberShots, noisePresent=noisePresent, RealDeviceName=RealDeviceName)\n",
    "    print(listForMusic)\n",
    "    if number==12:\n",
    "        listForMusic = RedistributeCell(listForMusic)\n",
    "    print(listForMusic)\n",
    "    sender(results=listForMusic, name=\"prob\")\n",
    "    del(circuit)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # app.run()\n",
    "  # test=hello_world()\n",
    "    FORMAT_CONS = '%(asctime)s %(name)-12s %(levelname)8s\\t%(message)s'\n",
    "    logging.basicConfig(level=logging.DEBUG, format=FORMAT_CONS)\n",
    "    # music = QuantumCircuit(4,4)\n",
    "    # ['qasm_simulator', 'ibmq_16_melbourne', 'ChooseEqualSuperposition', '1936', '0']\n",
    "    s=server()\n",
    "\n",
    "    while True:\n",
    "        while True:\n",
    "            (mystr, addr) = s.recvfrom(128*1024)\n",
    "            print(\"Message from MAX:{}\".format(mystr))\n",
    "            mystr=str(mystr)\n",
    "            mystr = mystr.split(\"'\")\n",
    "            mystr = mystr[1]\n",
    "            mystr = mystr.split(\"stop\")\n",
    "            mystr = mystr[0]\n",
    "            mystr = mystr.split(\"run\")\n",
    "            mystr = mystr[1]\n",
    "            mystr=mystr.strip()\n",
    "            mystr = mystr.split(\" \")\n",
    "            print(mystr)\n",
    "            #targ=format(3,'#06b')[2:]\n",
    "            targ=mystr[6]\n",
    "            targ=\"0\"*(4-len(targ))+targ\n",
    "\n",
    "            print(targ)\n",
    "            # listForMusic = ChooseBackEnd(music, backendType=mystr[0], qubitsToBeMeasured=range(4), numberShots=int(mystr[3]), noisePresent=True, RealDeviceName=mystr[1])\n",
    "            if mystr[4]=='1':\n",
    "                noise=True\n",
    "            elif mystr[4]=='1':\n",
    "                noise=False\n",
    "            else:\n",
    "                noise=False\n",
    "            print(int(mystr[6],2))\n",
    "            if mystr[2]==\"Hadamard\":\n",
    "                hadamard(backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,numberShots=int(mystr[3]),number=int(mystr[5]))\n",
    "            elif mystr[2]==\"BellStateGenerationTwoQubits\":\n",
    "                 Bell(backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,numberShots=int(mystr[3]),number=int(mystr[5]))\n",
    "            elif mystr[2]==\"ChooseEqualSuperposition\":\n",
    "                SeperPosition(backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,numberShots=int(mystr[3]),number=int(mystr[5]))\n",
    "            elif mystr[2]==\"Grover\":\n",
    "                grover4(target=targ, backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,number=int(mystr[5]))\n",
    "            else:\n",
    "                print(\"Command Not defined\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}