name_generator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Name Generator\n",
    "\n",
    "This generator generates pronounceable names up to 4 syllables. Letters have equal probablity of being chosen. However, if two consonants are selected to appear one after the other, how synergetic they are together is taken into account.\n",
    "\n",
    "The names follow the pattern consonant (c) -> vowel (v) -> c -> v -> c (or vice versa). Each stage adds either 1 or 2 letters--this is also randomly chosen.\n",
    "\n",
    "All random numbers are generated through quantum circuit measurements implemented with Qiskit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#required dictionaries\n",
    "cons = ['b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','w','x','y','z'] #consonants\n",
    "vows = ['a','u','e','i','o'] #vowels\n",
    "cons_or_vow = {'c': cons, 'v': vows} # consonants or vowels\n",
    "letter_type_dict = {'0':'c', '1':'v'}\n",
    "reverse_letter_type_dict = {'c':'0', 'v':'1'}\n",
    "\n",
    "letter_synergy_dict = {'b': ['l','r','w','y'], \n",
    "                       'c':['h', 'k', 'l', 'r','w','y'],\n",
    "                       'd':['h','r','w','y'],\n",
    "                       'f':['f','h','l','r','y'],\n",
    "                       'g':['h','y'],\n",
    "                       'h': ['m','y'], \n",
    "                       'j':['h','j','r','w','y'],\n",
    "                       'k':['h','y'],\n",
    "                       'l':['l','y'],\n",
    "                       'm':['h','y'], \n",
    "                       'n':['n','w','y'],\n",
    "                       'p':['p','h','l','r','w','y'],\n",
    "                       'q':['k','w','y'],\n",
    "                       'r':['h','r','y'],\n",
    "                       's':['h','l','p','r','s','t','v','w','y'],\n",
    "                       't':['h','r', 't', 'v','w','y','z'],\n",
    "                       'v':['h','l','v','y'],\n",
    "                       'w':['h','w'],\n",
    "                       'x':['l','r','w','x','y'],\n",
    "                       'y':['b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','x','z'],\n",
    "                       'z':['h','l','r','y','z']\n",
    "                       } # which consonants are synergetic when together? Not symmetric. Key letter followed by any of the letters in its value list.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the quantum part\n",
    "\n",
    "def run_QuantumCirc(n): # creates and runs a quantum circuit with a Hadamard operating on each qubit\n",
    "    qr = qiskit.QuantumRegister(n) # create quantum register with n qubits\n",
    "    cr = qiskit.ClassicalRegister(n) # create classical register with n bits\n",
    "    circ  = qiskit.QuantumCircuit(qr, cr) # create circuit with the two registers\n",
    "    circ.h(qr) # perform Hadamard  on each qubit\n",
    "    circ.measure(qr,cr) # each qubit is measured, and the outcome for one qubit is either 0 or 1\n",
    "    job = qiskit.execute(circ, qiskit.BasicAer.get_backend('qasm_simulator') ) \n",
    "    result = job.result().get_counts() \n",
    "    return result\n",
    "\n",
    "def random_quantum(num_choices): #returns random int between 0 and num_choices (not inclusive of num_choices)\n",
    "    if math.log(num_choices,2)%int(math.log(num_choices,2)) == 0: # checks whether log(num_choices) to the base 2 is a whole number\n",
    "        n = int(math.log(num_choices,2)) # n = number of qubits\n",
    "        result = run_QuantumCirc(n)\n",
    "        max_res = max(result, key=result.get) \n",
    "    else: \n",
    "        n = int(math.log(num_choices,2))+1 # adds 1 to log(N) to the base 2 to get total number of qubits needed\n",
    "        result = run_QuantumCirc(n)\n",
    "        max_res = max(result, key=result.get)\n",
    "        while(int(max_res,2) > num_choices-1): # find max that is less than num_choices\n",
    "            result.pop(str(max_res))\n",
    "            max_res = max(result, key=result.get)\n",
    "    random_number = int(max_res,2)\n",
    "    return random_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generating the letters and eventually the name\n",
    "\n",
    "def return_letters(c_or_v, num_letters): # returns one or two letters\n",
    "    letter_array = cons_or_vow[c_or_v] #are we dealing with consonants or vowels?\n",
    "    if num_letters == 1: #r eturning one letter\n",
    "        ind = random_quantum(len(letter_array))\n",
    "        return letter_array[ind]\n",
    "    else: #returning two letters\n",
    "        ind1 = random_quantum(len(letter_array))\n",
    "        ind2 = random_quantum(len(letter_array))\n",
    "        if c_or_v == 'c': #if we're dealing with consonants, need to check whether the 2 are synergetic\n",
    "            if letter_array[ind2] in letter_synergy_dict[letter_array[ind1]]:\n",
    "                return letter_array[ind1]+letter_array[ind2]\n",
    "            else:\n",
    "                return letter_array[ind1]\n",
    "        else:\n",
    "            return letter_array[ind1]+letter_array[ind2]\n",
    "\n",
    "def make_name(): #names are made in the pattern c>v>c>v>c etc. each can be one or two letters\n",
    "    syllables = random_quantum(4) + 1 # names with up to 4 syllables\n",
    "    word = []\n",
    "    letter_type = letter_type_dict[str(random_quantum(2))] #selects whether the opening letters are consonants or vowels\n",
    "    word += return_letters(letter_type,random_quantum(2)+1) #generates first part\n",
    "    while syllables >0: #generates the rest of the syllables\n",
    "        letter_type = letter_type_dict[str(int(reverse_letter_type_dict[letter_type])^1)] # toggles c -> v and v->c, ^ is xor\n",
    "        word += return_letters(letter_type,random_quantum(2)+1)\n",
    "        syllables-=1\n",
    "    \n",
    "    return str(''.join(word)).capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opaac\n",
      "Eca\n",
      "Uiloolea\n",
      "Siodauf\n",
      "Rabio\n",
      "Deji\n",
      "Kai\n",
      "Vi\n"
     ]
    }
   ],
   "source": [
    "print(make_name())\n",
    "print(make_name())\n",
    "print(make_name())\n",
    "print(make_name())\n",
    "print(make_name())\n",
    "print(make_name())\n",
    "print(make_name())\n",
    "print(make_name())"
   ]
  },
  {
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}