QServer_Shors.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "associate-status",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# Importing standard Qiskit libraries\n",
    "from qiskit import QuantumCircuit, execute, Aer, IBMQ\n",
    "from qiskit.compiler import transpile, assemble\n",
    "from qiskit.tools.jupyter import *\n",
    "from qiskit.visualization import *\n",
    "from ibm_quantum_widgets import *\n",
    "from qiskit.providers.aer import QasmSimulator\n",
    "import math\n",
    "# Loading your IBM Q account(s)\n",
    "provider = IBMQ.load_account()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "logical-train",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.aqua.algorithms import Shor\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from qiskit.tools.visualization import plot_histogram\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "sixth-characteristic",
   "metadata": {},
   "outputs": [],
   "source": [
    "#backend = Aer.get_backend('qasm_simulator')\n",
    "backend= QasmSimulator(method='automatic')\n",
    "quantum_instance=QuantumInstance(backend, shots=1000)\n",
    "my_shor=Shor(N=35,a=3,quantum_instance=quantum_instance)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "wired-romania",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n",
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-31-ad0c4e81c996>\"\u001b[1;36m, line \u001b[1;32m2\u001b[1;36m, in \u001b[1;35m<module>\u001b[1;36m\u001b[0m\n",
      "\u001b[1;33m    p_dec=shor_result['factors'][0]\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m\u001b[1;31m:\u001b[0m name 'shor_result' is not defined\n",
      "\n",
      "Use %tb to get the full traceback.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       ".button {\n",
       "  border: none;\n",
       "  color: white;\n",
       "  padding: 4px 8px;\n",
       "  text-align: center;\n",
       "  text-decoration: none;\n",
       "  display: inline-block;\n",
       "  font-size: 12px;\n",
       "  margin: 4px 2px;\n",
       "  transition-duration: 0.2s;\n",
       "  cursor: pointer;\n",
       "}\n",
       ".iqx-button {\n",
       "  background-color: #0f62fe; \n",
       "  color: white; \n",
       "}\n",
       ".iqx-button:hover {\n",
       "  background-color: #0043ce;\n",
       "  color: white;\n",
       "}\n",
       "</style>\n",
       "<a href=\"https://stackoverflow.com/search?q=NameError: name 'shor_result' is not defined\" target='_blank'><button class='button iqx-button'>Search for solution online</button></a>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "shor_r=Shor.run(my_shor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "difficult-hypothesis",
   "metadata": {},
   "outputs": [],
   "source": [
    "The code below implements the above circuit to decrypt the number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "addressed-antenna",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gmpy2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "particular-combine",
   "metadata": {},
   "outputs": [],
   "source": [
    "number_to_encrypt = 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "popular-treat",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "egcd 1 1 0\n",
      "egcd 1 -5 1\n",
      "egcd 1 11 -5\n",
      "egcd 1 -27 11\n",
      "egcd 1 11 -27\n",
      "Encypted number:  24\n",
      "Decrypted plain number:  19\n"
     ]
    }
   ],
   "source": [
    "\n",
    "p = 7\n",
    "q = 5\n",
    "e = 59 #input from user\n",
    "\n",
    "# Small note: if the number to encrypt has more digits than\n",
    "# the modulus the algorithm won't work\n",
    "\n",
    "# This function returns True if coprime_to_check is coprime with phi_n\n",
    "def is_coprime_phi(phi_n, coprime_to_check):\n",
    "    while phi_n % coprime_to_check == 0:\n",
    "        coprime_to_check = input(\"Enter a prime number, to check if coprime with phi_n\")\n",
    "        e = coprime_to_check\n",
    "    return True\n",
    "\n",
    "# If e is not coprime with phi(n) ValueError is raised\n",
    "if not is_coprime_phi(phi_n,e):\n",
    "    raise ValueError(\"e is not coprime with phi_n\")\n",
    "\n",
    "#  modular multiplicative inverse\n",
    "def egcd(a, b):\n",
    "    if a == 0:\n",
    "        return (b, 0, 1)\n",
    "    else:\n",
    "        g, y, x = egcd(b % a, a)\n",
    "        print (\"egcd\",g, x - (b // a) * y, y)\n",
    "        return (g, x - (b // a) * y, y)\n",
    "\n",
    "\n",
    "def modinv(coprime, phi_n):\n",
    "    g, x, y = egcd(coprime, phi_n)\n",
    "    if g != 1:\n",
    "        raise Exception('modular inverse does not exist')\n",
    "    else:\n",
    "        return x % phi_n\n",
    "# We find n\n",
    "n = p*q\n",
    "\n",
    "# Public key\n",
    "pub_k = [e,n]\n",
    "\n",
    "# Encrypting and decrypting functions\n",
    "def encrypt_this(m):\n",
    "    result = gmpy2.powmod(m,e,n)\n",
    "    return result\n",
    "\n",
    "###Decrypting without a private key and n as public key\n",
    "\n",
    "my_shor=Shor(N=n,a=3,quantum_instance=quantum_instance)\n",
    "shor_result=Shor.run(my_shor)\n",
    "my_list=shor_result['factors']\n",
    "p_dec=shor_r['factors'][0][0]\n",
    "q_dec=shor_r['factors'][0][1]\n",
    "phi_n = (p_dec-1)*(q_dec-1)\n",
    "\n",
    "# The modular multiplicative inverse\n",
    "d = modinv(e,phi_n)\n",
    "# Private key\n",
    "#priv_k = [d,n]\n",
    "\n",
    "def decrypt_this(c):\n",
    "    \n",
    "    plain = gmpy2.powmod(c,d,n)\n",
    "    return plain\n",
    "\n",
    "###########################################################\n",
    "\n",
    "# Encrypt \n",
    "enc = encrypt_this(number_to_encrypt)\n",
    "print(\"Encypted number: \",enc)\n",
    "\n",
    "# Decrypt\n",
    "dec = decrypt_this(enc)\n",
    "print(\"Decrypted plain number: \",dec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "complete-exhibition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computed of qubits for circuit: 26\n",
      "Actual number of qubits of circuit: 26\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(f'Computed of qubits for circuit: {4 * math.ceil(math.log(n, 2)) + 2}')\n",
    "print(f'Actual number of qubits of circuit: {my_shor.construct_circuit().num_qubits}')"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}