SimpleHashCollisions.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Initially connects to the azure server. Needs to be filled by specific user's azure information. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "import qsharp.azure\n",
        "targets = qsharp.azure.connect(\n",
        "    resourceId=\"...\",\n",
        "    location=\"westus\")\n",
        "SimpleHashCollisions: any = None"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Main Q# code. Implementation of Grover's search algorithm mainly sourced from [here.](https://learn.microsoft.com/en-us/azure/quantum/tutorial-qdk-grovers-search?tabs=tabid-visualstudio)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "microsoft": {
          "language": "qsharp"
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "%%qsharp\n",
        "open Microsoft.Quantum.Canon;\n",
        "open Microsoft.Quantum.Intrinsic;\n",
        "open Microsoft.Quantum.Measurement;\n",
        "open Microsoft.Quantum.Math;\n",
        "open Microsoft.Quantum.Convert;\n",
        "open Microsoft.Quantum.Arithmetic;\n",
        "open Microsoft.Quantum.Arrays;\n",
        "open Microsoft.Quantum.Preparation;\n",
        "\n",
        "@EntryPoint()\n",
        "operation SimpleHashCollisions(hash : Int) : Result[] {\n",
        "    mutable permutationArray = new Int[128];\n",
        "    for (i in 0 .. 127) {\n",
        "        set permutationArray w/= i <- (3123 * 458 + (i * i)) % 128; \n",
        "    }\n",
        "    let inputBitSize = 5;\n",
        "    let markingOracle = MarkHasher(hash, _, _, permutationArray);\n",
        "    let phaseOracle = ApplyMarkingOracleAsPhaseOracle(markingOracle, _);\n",
        "    let totalHashes = 32; // 2 ** inputBitSize\n",
        "    let nSolutions = 8; // 8 - 5 = 3, 2 ** 3\n",
        "    let nIterations = Round(PI() / 4.0 * Sqrt(IntAsDouble(totalHashes) / IntAsDouble(nSolutions)));\n",
        "    use register = Qubit[8];\n",
        "    RunGroversSearch(register, phaseOracle, nIterations);\n",
        "    let res = MultiM(register);\n",
        "    return res;\n",
        "}\n",
        "\n",
        "operation MarkHasher (\n",
        "hashToCheck : Int,\n",
        "inputQubits : Qubit[],\n",
        "target : Qubit,\n",
        "permutationArray : Int[]\n",
        ") : Unit is Adj + Ctl {\n",
        "use checkQubits = Qubit[5];\n",
        "use hashedQubits = Qubit[5];\n",
        "    \n",
        "let inp = LittleEndian(inputQubits);\n",
        "let check = LittleEndian(checkQubits);\n",
        "let hashed = LittleEndian(hashedQubits);\n",
        "within {\n",
        "    ApplyXorInPlace(hashToCheck, check);\n",
        "    for (i in 217 .. 221) {\n",
        "        ApplyXorInPlace(permutationArray[(i * i)%128], inp);\n",
        "    }\n",
        "    for (i in 0 .. Length(hashedQubits) - 1) {\n",
        "        CNOT(inputQubits[i],hashedQubits[i]);\n",
        "    }\n",
        "    for (i in 0 .. Length(checkQubits) - 1) {\n",
        "        CNOT(hashedQubits[i],checkQubits[i]);\n",
        "    }\n",
        "    ApplyToEachA(X, checkQubits);\n",
        "} apply {\n",
        "    Controlled X(checkQubits, target);\n",
        "    }\n",
        "}\n",
        "\n",
        "operation PrepareUniformSuperpositionOverDigits(digitReg : Qubit[]) : Unit is Adj + Ctl {\n",
        "    PrepareArbitraryStateCP(ConstantArray(10, ComplexPolar(1.0, 0.0)), LittleEndian(digitReg));\n",
        "}\n",
        "\n",
        "operation ApplyMarkingOracleAsPhaseOracle(\n",
        "    markingOracle : (Qubit[], Qubit) => Unit is Adj,\n",
        "    register : Qubit[]\n",
        ") : Unit is Adj {\n",
        "    use target = Qubit();\n",
        "    within {\n",
        "        X(target);\n",
        "        H(target);\n",
        "    } apply {\n",
        "        markingOracle(register, target);\n",
        "    }\n",
        "}\n",
        "\n",
        "operation RunGroversSearch(register : Qubit[], phaseOracle : ((Qubit[]) => Unit is Adj), iterations : Int) : Unit {\n",
        "    ApplyToEach(H, register);\n",
        "    for _ in 1 .. iterations {\n",
        "        phaseOracle(register);\n",
        "        ReflectAboutUniform(register);\n",
        "    }\n",
        "}\n",
        "\n",
        "operation ReflectAboutUniform(inputQubits : Qubit[]) : Unit {\n",
        "    within {\n",
        "        ApplyToEachA(H, inputQubits);\n",
        "        ApplyToEachA(X, inputQubits);\n",
        "    } apply {\n",
        "            Controlled Z(Most(inputQubits), Tail(inputQubits));\n",
        "    }\n",
        "}\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This connects python to the remote server instance and runs the code 100 times with a hash value of 7 (or 0b00111)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "qsharp.azure.target(\"ionq.qpu.aria-1\")\n",
        "\n",
        "result = qsharp.azure.execute(SimpleHashCollisions,hash=7, shots=100, jobName=\"Calculate collisions\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "After the job is completed, displays data visually. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "from matplotlib import pyplot\n",
        "pyplot.bar(result.keys(), result.values())\n",
        "pyplot.title(\"Hash collisions on n = 8 input size and m = 5 hash size\")\n",
        "pyplot.xlabel(\"Input  (converted from binary)\")\n",
        "pyplot.xscale(\"linear\")\n",
        "pyplot.ylabel(\"Probability\")\n",
        "for i, j in zip(result.keys(), result.values()):\n",
        "    if (j > 0.07):\n",
        "        print(i.replace(',',\"\"))\n",
        "pyplot.show()"
      ]
    },
    {
      "attachments": {
        "simprob.png": {
          "image/png": "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"
        }
      },
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Output on the cloud simulator will look like:\n",
        "[00010000]\n",
        "[00010100]\n",
        "[00010010]\n",
        "[00010110]\n",
        "[00010001]\n",
        "[00010101]\n",
        "[00010011]\n",
        "[00010111]\n",
        "\n",
        "![simprob.png](attachment:simprob.png)\n"
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "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.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)]"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    },
    "vscode": {
      "interpreter": {
        "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}