tutorial.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QYbNkQwK0fSB"
      },
      "source": [
        "# **Quantum Exact String Matching (ESM)**\n",
        "\n",
        "In this tutorial, our focus lies on a Quantum Exact String Matching algorithm implementation. Its essence lies in identifying an occurrence of a specified pattern $x$, typically denoted by length $m$, within a text $y$ of length $n$ $\\geq$ $m$, where both sequences are composed of characters taken from an alphabet $\\Sigma$ of size $\\sigma$. Our article presents an initial practical implementation of a quantum circuit tailored to address the exact string matching problem, particularly focusing on binary strings.\n",
        "\n",
        "For instance, consider the pattern `101`. Within the text `11010100`, the pattern exhibits two occurrences.\n",
        "\n",
        "A classical **naïve** approach exhibits a worst-case time complexity of $\\mathcal{O}(mn)$, contrasting with the capability of quantum computation to achieve a $\\tilde{O}(\\sqrt{n})$ complexity using **Grover's search** - which searches a desired item within an unstructured dataset of size $n$, realizing a quadratic speed-up compared to classical methods.\n",
        "\n",
        "This tutorial uses the **Qiskit** open-source toolkit developed by **IBM** and based on Python language. While current real-world hardware often struggles to produce valid results due to decoherence and quantum errors, particularly when dealing with lengthy texts, this study presents experimental results from a circuit simulation on classical hardware, validating the proposed implementation's efficacy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8BPayXur0fSD"
      },
      "outputs": [],
      "source": [
        "# Practical Implementation of a Quantum String Matching Algorithm\n",
        "# S. Faro, F.P. Marino, and A. Scardace\n",
        "# QUASAR 2024, ACM HPDC\n",
        "\n",
        "%%capture\n",
        "%pip install ibm-cloud-sdk-core==3.18.2\n",
        "%pip install qiskit==0.45.1\n",
        "%pip install qiskit-aer==0.13.1\n",
        "%pip install pylatexenc==2.10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "t8fI4B8P0fSE"
      },
      "outputs": [],
      "source": [
        "from numpy import log2, sqrt\n",
        "from numpy import pi\n",
        "\n",
        "from qiskit.tools.visualization import plot_histogram\n",
        "from qiskit.circuit.gate import Gate\n",
        "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
        "from qiskit import Aer\n",
        "from qiskit import transpile"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IknGJIzF7LQD"
      },
      "source": [
        "## Utility Functions\n",
        "\n",
        "A first utility function is useful to execute a quantum circuit on the IBM simulator and retrieve the counts of measurement outcomes. It takes two parameters: the quantum circuit to be executed, and the number of repetitions of the circuit to run. After the circuit executions are completed, the function retrieves the result of the job and returns a dictionary containing the binary representation of measurement outcomes and their respective counts. Overall, this function helps us avoid duplication of code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "wfM0czb80fSE"
      },
      "outputs": [],
      "source": [
        "def run(circuit: QuantumCircuit, shots: int) -> dict:\n",
        "    simulator = Aer.get_backend('aer_simulator')\n",
        "    compiled_circuit = transpile(circuit, simulator)\n",
        "    job = simulator.run(compiled_circuit, shots=shots)\n",
        "    result = job.result()\n",
        "    return result.get_counts(compiled_circuit)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LsyrbYM7_EKI"
      },
      "source": [
        "This function initializes a quantum register based on the given binary string, which represents its initial state. The function applies an $X$ gate to the $i$-th qubit of the quantum register if `bin_str[i] = 1`. Overall, this function enables the convenient initialization of a quantum register, allowing for the preparation of specific quantum states for further quantum computation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "GeVUxD1WLOQX"
      },
      "outputs": [],
      "source": [
        "def init_register(bin_str: str) -> QuantumCircuit:\n",
        "    data_qr = QuantumRegister(len(bin_str), 'data')\n",
        "    qc = QuantumCircuit(data_qr)\n",
        "\n",
        "    for i, bit in enumerate(bin_str):\n",
        "        if bit == '1':\n",
        "            qc.x(data_qr[i])\n",
        "\n",
        "    return qc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dNPgZXP8BIYk"
      },
      "source": [
        "Let's try to build the circuit for a $4$-qubit register."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        },
        "id": "Ki85-L46LQ0u",
        "outputId": "272260de-c08f-4a10-dfd4-669626146111"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐\n",
              "data_0: ┤ X ├\n",
              "        └───┘\n",
              "data_1: ─────\n",
              "             \n",
              "data_2: ─────\n",
              "        ┌───┐\n",
              "data_3: ┤ X ├\n",
              "        └───┘</pre>"
            ],
            "text/plain": [
              "        ┌───┐\n",
              "data_0: ┤ X ├\n",
              "        └───┘\n",
              "data_1: ─────\n",
              "             \n",
              "data_2: ─────\n",
              "        ┌───┐\n",
              "data_3: ┤ X ├\n",
              "        └───┘"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "classical_value = '1001'\n",
        "init_register(classical_value).draw(fold=255)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qLr2CiPWECH5"
      },
      "source": [
        "## The Parameterized Cyclic Rotation Operator\n",
        "\n",
        "In this section, we present the implementation of the quantum cyclic rotation operator, as described by **Pavone** and **Viola**. The circuit will then be integrated by a parameter that will allow the amplitude of the rotation to be applied to the quantum register to be arbitrarily defined. Furthermore, the operator is implemented to provide rotations **towards the left**.\n",
        "\n",
        "This function implements a procedure that, using a series of SWAP gates, cyclically shifts a quantum register of size $n$ by $s = 2^k$ positions to the left. The depth of the final quantum circuit does not exceed the value $\\log(n)$. As a result of this rotation, the qubit at position $(i+s)\\bmod{n}$ of the register is moved to position $i$, where $0\\leq i < n$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "5sJR-fCM0fSE"
      },
      "outputs": [],
      "source": [
        "def rot(n: int, s: int) -> QuantumCircuit:\n",
        "    y_qr = QuantumRegister(n, 'y')\n",
        "    qc = QuantumCircuit(y_qr, name='ROT_' + str(s))\n",
        "\n",
        "    for i in range(1, (int(log2(n)) - int(log2(s)) + 2)):\n",
        "        for j in range(int(n / (s * (2**i)))):\n",
        "            for q in range(j * s * (2**i), s * (j*2 ** i+1)):\n",
        "                qc.swap(n - 1 - (q+s), n - 1 - (q+2 ** (i-1) * s + s))\n",
        "\n",
        "    return qc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tIXKwG16FAUr"
      },
      "source": [
        "Let's try to build the circuit for an $8$-qubit register and apply a rotation of 2 positions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "Sf-2uhn02WWj",
        "outputId": "043e164a-1192-4315-a389-32a7dfc18ece"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                       \n",
              "y_0: ──────────X─────X─\n",
              "               │     │ \n",
              "y_1: ───────X──┼──X──┼─\n",
              "            │  │  │  │ \n",
              "y_2: ────X──┼──┼──┼──┼─\n",
              "         │  │  │  │  │ \n",
              "y_3: ─X──┼──┼──┼──┼──┼─\n",
              "      │  │  │  │  │  │ \n",
              "y_4: ─┼──X──┼──┼──┼──X─\n",
              "      │     │  │  │    \n",
              "y_5: ─X─────┼──┼──X────\n",
              "            │  │       \n",
              "y_6: ───────┼──X───────\n",
              "            │          \n",
              "y_7: ───────X──────────\n",
              "                       </pre>"
            ],
            "text/plain": [
              "                       \n",
              "y_0: ──────────X─────X─\n",
              "               │     │ \n",
              "y_1: ───────X──┼──X──┼─\n",
              "            │  │  │  │ \n",
              "y_2: ────X──┼──┼──┼──┼─\n",
              "         │  │  │  │  │ \n",
              "y_3: ─X──┼──┼──┼──┼──┼─\n",
              "      │  │  │  │  │  │ \n",
              "y_4: ─┼──X──┼──┼──┼──X─\n",
              "      │     │  │  │    \n",
              "y_5: ─X─────┼──┼──X────\n",
              "            │  │       \n",
              "y_6: ───────┼──X───────\n",
              "            │          \n",
              "y_7: ───────X──────────\n",
              "                       "
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "num_qubits = 8\n",
        "shift_value = 2\n",
        "rot(num_qubits, shift_value).draw(fold=255)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w3QW32AjGMtx"
      },
      "source": [
        "Subsequently, it is necessary to create a function that allows to transform the rotation operator into a quantum gate. It enhances the versatility and modularity of quantum circuit design for the next quantum algorithm implementations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "T9s2doo-bKG0"
      },
      "outputs": [],
      "source": [
        "def rot_gate(n: int, s: int) -> Gate:\n",
        "    rot_circuit = rot(n, s)\n",
        "    return rot_circuit.to_gate(label='ROT_' + str(s))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kZ52PTgrJ3tO"
      },
      "source": [
        "The following function creates a parameterized version of the rotation operator. This circuit involves the use of a register $|j\\rangle$ of $log(n)$ qubits, where $n$ is the size of the quantum register $|y\\rangle$ on which to apply the rotation. The register $|j\\rangle$ will contain the binary representation of the amplitude $s$ of the rotation to be applied, with $0 \\leq s < n$. For any given value of $i$ such that $0 \\leq i < \\log(n)$, the application of the rotation operator $ROT$_${2^i}$ to register $|y\\rangle$ is controlled by the qubit $|j_i\\rangle$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "yoL5g_T96oPI"
      },
      "outputs": [],
      "source": [
        "def parameterized_rot(n: int) -> QuantumCircuit:\n",
        "    j_qr = QuantumRegister(int(log2(n)), 'j')\n",
        "    y_qr = QuantumRegister(n, 'y')\n",
        "    qc = QuantumCircuit(j_qr, y_qr)\n",
        "\n",
        "    for i in range(int(log2(n))):\n",
        "        crot = rot_gate(n, 2**i).control(1)\n",
        "        qc = qc.compose(crot, [j_qr[i]] + y_qr[:])\n",
        "\n",
        "    return qc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GkabsTSQKbEF"
      },
      "source": [
        "Below, we show the quantum circuit that is generated by the parameterized rotation operator acting on an $8$-qubit register."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 371
        },
        "id": "l4bdhRtm7EU0",
        "outputId": "4d21f793-4076-4d8d-8ebd-7781a42193ca"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                                   \n",
              "j_0: ────■─────────────────────────\n",
              "         │                         \n",
              "j_1: ────┼─────────■───────────────\n",
              "         │         │               \n",
              "j_2: ────┼─────────┼─────────■─────\n",
              "     ┌───┴────┐┌───┴────┐┌───┴────┐\n",
              "y_0: ┤0       ├┤0       ├┤0       ├\n",
              "     │        ││        ││        │\n",
              "y_1: ┤1       ├┤1       ├┤1       ├\n",
              "     │        ││        ││        │\n",
              "y_2: ┤2       ├┤2       ├┤2       ├\n",
              "     │        ││        ││        │\n",
              "y_3: ┤3       ├┤3       ├┤3       ├\n",
              "     │  ROT_1 ││  ROT_2 ││  ROT_4 │\n",
              "y_4: ┤4       ├┤4       ├┤4       ├\n",
              "     │        ││        ││        │\n",
              "y_5: ┤5       ├┤5       ├┤5       ├\n",
              "     │        ││        ││        │\n",
              "y_6: ┤6       ├┤6       ├┤6       ├\n",
              "     │        ││        ││        │\n",
              "y_7: ┤7       ├┤7       ├┤7       ├\n",
              "     └────────┘└────────┘└────────┘</pre>"
            ],
            "text/plain": [
              "                                   \n",
              "j_0: ────■─────────────────────────\n",
              "         │                         \n",
              "j_1: ────┼─────────■───────────────\n",
              "         │         │               \n",
              "j_2: ────┼─────────┼─────────■─────\n",
              "     ┌───┴────┐┌───┴────┐┌───┴────┐\n",
              "y_0: ┤0       ├┤0       ├┤0       ├\n",
              "     │        ││        ││        │\n",
              "y_1: ┤1       ├┤1       ├┤1       ├\n",
              "     │        ││        ││        │\n",
              "y_2: ┤2       ├┤2       ├┤2       ├\n",
              "     │        ││        ││        │\n",
              "y_3: ┤3       ├┤3       ├┤3       ├\n",
              "     │  ROT_1 ││  ROT_2 ││  ROT_4 │\n",
              "y_4: ┤4       ├┤4       ├┤4       ├\n",
              "     │        ││        ││        │\n",
              "y_5: ┤5       ├┤5       ├┤5       ├\n",
              "     │        ││        ││        │\n",
              "y_6: ┤6       ├┤6       ├┤6       ├\n",
              "     │        ││        ││        │\n",
              "y_7: ┤7       ├┤7       ├┤7       ├\n",
              "     └────────┘└────────┘└────────┘"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "num_qubits = 8\n",
        "parameterized_rot(num_qubits).draw(fold=255)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "69qoC0bnrQB4"
      },
      "source": [
        "It is now possible to compile the circuit operating in superposition, obtaining the $8$ possible configurations of the $|j\\rangle$ register. At the time of measurement, only one of them will be observed. However, running the circuit $100$ times, highlights how all possible configurations are present as a result, each with an equal probability of being observed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "De-GwkovpE49",
        "outputId": "89952d42-097e-4dad-d1ec-2235010cd0b7"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "text = '10110001'\n",
        "text_length = len(text)\n",
        "\n",
        "shift_qr = QuantumRegister(int(log2(text_length)), 'shift')\n",
        "text_qr = QuantumRegister(text_length, 'text')\n",
        "output_cr = ClassicalRegister(text_length, 'output_classic')\n",
        "circ = QuantumCircuit(shift_qr, text_qr, output_cr)\n",
        "\n",
        "circ.h(shift_qr)\n",
        "circ.append(init_register(text), text_qr[:])\n",
        "circ.append(parameterized_rot(text_length), shift_qr[:] + text_qr[:])\n",
        "circ.measure(text_qr, output_cr)\n",
        "\n",
        "counts = run(circ, 100)\n",
        "plot_histogram(counts, title='Rotate ' + text + ' Leftward in Superposition')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vC11ZJhR7aEn"
      },
      "source": [
        "## The Match Operator\n",
        "\n",
        "The Match operator allows comparison between two binary strings of equal length $m$. The comparison is performed to verify that the two strings are identical by altering the output qubit to $|1\\rangle$ only if $x=y$. This comparison is carried out through $m$ CNOT gates running in parallel where $|x_i\\rangle$ is used as control and $|y_i\\rangle$ is used as the target. Subsequently, the qubits of the $|y\\rangle$ register are negated. At this point, we will have $|y_i\\rangle = |1\\rangle$ if and only if $x_i=y_i$. Simply apply a multiple CNOT to verify that the register $|y\\rangle$ is equal to $|1\\rangle^m$. The circuit is completed by uncompute operations that restore the original values of $|x\\rangle$ and $|y\\rangle$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "tnkBXcHD7avc"
      },
      "outputs": [],
      "source": [
        "def match(m: int) -> QuantumCircuit:\n",
        "    x_qr = QuantumRegister(m, 'x')\n",
        "    y_qr = QuantumRegister(m, 'y')\n",
        "    out_qr = QuantumRegister(1, 'out')\n",
        "    qc = QuantumCircuit(x_qr, y_qr, out_qr)\n",
        "\n",
        "    for i in range(m):\n",
        "        qc.cx(x_qr[i], y_qr[i])\n",
        "        qc.x(y_qr[i])\n",
        "\n",
        "    qc.mcx(y_qr[:], out_qr)\n",
        "\n",
        "    for i in reversed(range(m)):\n",
        "        qc.x(y_qr[i])\n",
        "        qc.cx(x_qr[i], y_qr[i])\n",
        "\n",
        "    return qc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTulv6V4PhWQ"
      },
      "source": [
        "Below, we show the circuit created by the Match operator if applied on strings of length $m=4$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        },
        "id": "r3W7-Beh0fSF",
        "outputId": "1c1c44e7-e6d4-4743-c101-791259c0dc19"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                                                            \n",
              "x_0: ──■─────────────────────────────────────────────────■──\n",
              "       │                                                 │  \n",
              "x_1: ──┼────■───────────────────────────────────────■────┼──\n",
              "       │    │                                       │    │  \n",
              "x_2: ──┼────┼────■─────────────────────────────■────┼────┼──\n",
              "       │    │    │                             │    │    │  \n",
              "x_3: ──┼────┼────┼────■───────────────────■────┼────┼────┼──\n",
              "     ┌─┴─┐  │    │    │  ┌───┐     ┌───┐  │    │    │  ┌─┴─┐\n",
              "y_0: ┤ X ├──┼────┼────┼──┤ X ├──■──┤ X ├──┼────┼────┼──┤ X ├\n",
              "     └───┘┌─┴─┐  │    │  ├───┤  │  ├───┤  │    │  ┌─┴─┐└───┘\n",
              "y_1: ─────┤ X ├──┼────┼──┤ X ├──■──┤ X ├──┼────┼──┤ X ├─────\n",
              "          └───┘┌─┴─┐  │  ├───┤  │  ├───┤  │  ┌─┴─┐└───┘     \n",
              "y_2: ──────────┤ X ├──┼──┤ X ├──■──┤ X ├──┼──┤ X ├──────────\n",
              "               └───┘┌─┴─┐├───┤  │  ├───┤┌─┴─┐└───┘          \n",
              "y_3: ───────────────┤ X ├┤ X ├──■──┤ X ├┤ X ├───────────────\n",
              "                    └───┘└───┘┌─┴─┐└───┘└───┘               \n",
              "out: ─────────────────────────┤ X ├─────────────────────────\n",
              "                              └───┘                         </pre>"
            ],
            "text/plain": [
              "                                                            \n",
              "x_0: ──■─────────────────────────────────────────────────■──\n",
              "       │                                                 │  \n",
              "x_1: ──┼────■───────────────────────────────────────■────┼──\n",
              "       │    │                                       │    │  \n",
              "x_2: ──┼────┼────■─────────────────────────────■────┼────┼──\n",
              "       │    │    │                             │    │    │  \n",
              "x_3: ──┼────┼────┼────■───────────────────■────┼────┼────┼──\n",
              "     ┌─┴─┐  │    │    │  ┌───┐     ┌───┐  │    │    │  ┌─┴─┐\n",
              "y_0: ┤ X ├──┼────┼────┼──┤ X ├──■──┤ X ├──┼────┼────┼──┤ X ├\n",
              "     └───┘┌─┴─┐  │    │  ├───┤  │  ├───┤  │    │  ┌─┴─┐└───┘\n",
              "y_1: ─────┤ X ├──┼────┼──┤ X ├──■──┤ X ├──┼────┼──┤ X ├─────\n",
              "          └───┘┌─┴─┐  │  ├───┤  │  ├───┤  │  ┌─┴─┐└───┘     \n",
              "y_2: ──────────┤ X ├──┼──┤ X ├──■──┤ X ├──┼──┤ X ├──────────\n",
              "               └───┘┌─┴─┐├───┤  │  ├───┤┌─┴─┐└───┘          \n",
              "y_3: ───────────────┤ X ├┤ X ├──■──┤ X ├┤ X ├───────────────\n",
              "                    └───┘└───┘┌─┴─┐└───┘└───┘               \n",
              "out: ─────────────────────────┤ X ├─────────────────────────\n",
              "                              └───┘                         "
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "pattern_length = 4\n",
        "match(pattern_length).draw(fold=255)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_ZsTeIS6WHd"
      },
      "source": [
        "In order to evaluate the functioning of the Match operator, we perform the comparison between a binary string $y = 1011$ and all the possible configurations of a $4$-bit binary string $x$ by applying the $H$ gate on each qubit of $|x\\rangle$. The Match operator is then applied to the quantum registers $|x\\rangle$ and $|y\\rangle$ and you can easily see that just one solution has the last qubit equals to $|1\\rangle$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 518
        },
        "id": "MBdmdFf06x6_",
        "outputId": "71267ba5-65d6-4a7c-c64d-1f9bd6a0a36e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "text = '1011'\n",
        "text_length = len(text)\n",
        "\n",
        "pattern_qr = QuantumRegister(text_length, 'pattern')\n",
        "text_qr = QuantumRegister(text_length, 'text')\n",
        "output_qr = QuantumRegister(1, 'output')\n",
        "output_cr = ClassicalRegister(text_length + 1, 'output_classic')\n",
        "circ = QuantumCircuit(pattern_qr, text_qr, output_qr, output_cr)\n",
        "\n",
        "circ.h(pattern_qr)\n",
        "circ.append(init_register(text), text_qr[:])\n",
        "circ.append(match(text_length), pattern_qr[:] + text_qr[:] + output_qr[:])\n",
        "circ.measure(pattern_qr, output_cr[:-1])\n",
        "circ.measure(output_qr, output_cr[-1])\n",
        "\n",
        "counts = run(circ, 100)\n",
        "plot_histogram(counts, title='Matching ' + text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dwfgA_1MQGxM"
      },
      "source": [
        "Following that, it is necessary to create a function that allows to transform the exact match operator into a quantum gate. It takes one parameter: the length $m$ of the two strings we want to compare."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "tRNt39YM7lB7"
      },
      "outputs": [],
      "source": [
        "def match_gate(m: int) -> Gate:\n",
        "    match_circuit = match(m)\n",
        "    return match_circuit.to_gate(label='MATCH')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oXDwFjim7fL9"
      },
      "source": [
        "## The Exact String Matching Quantum Oracle\n",
        "\n",
        "Through the use of the parameterized rotation operator and the match operator, it is now possible to implement an ESM operator to search for an exact occurrence of a pattern $x$ within a text $y$. It checks if a pattern is present as a prefix in a text, where the text $y$ is rotated by a certain shift value $j$ which can be in superposition, allowing for flexible alignment of the pattern within the text.\n",
        "\n",
        "The shift value $s$ is encoded inside the quantum register $|j\\rangle$. Two other quantum registers $|x\\rangle$ and $|y\\rangle$ are initialized to contain the two strings $x$ and $y$. Then, the text string is rotated $s$ positions to the left. This way, the string $y[s..s+m-1]$ will have been placed as a prefix in the quantum register $|y\\rangle$. Using the MATCH operator, we compare the first $m$ qubits of $|x\\rangle$ with the first $m$ qubits of $|y\\rangle$ and the result of this comparison is recorded in $|out\\rangle$. The circuit is completed by uncompute, which sets the values of the registers to their initial state."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "pP3WT6G75rz2"
      },
      "outputs": [],
      "source": [
        "def esm(m: int, n: int) -> QuantumCircuit:\n",
        "    j_qr = QuantumRegister(int(log2(n)), 'j')\n",
        "    x_qr = QuantumRegister(m, 'x')\n",
        "    y_qr = QuantumRegister(n, 'y')\n",
        "    out = QuantumRegister(1, 'out')\n",
        "\n",
        "    qc = QuantumCircuit(\n",
        "        j_qr,\n",
        "        x_qr,\n",
        "        y_qr,\n",
        "        out\n",
        "    )\n",
        "\n",
        "    qc = qc.compose(parameterized_rot(n), j_qr[:] + y_qr[:])\n",
        "    qc = qc.compose(match_gate(m), x_qr[:] + y_qr[:m] + out[:])\n",
        "    qc = qc.compose(parameterized_rot(n).inverse(), j_qr[:] + y_qr[:])\n",
        "\n",
        "    return qc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y5G75pGdUoqP"
      },
      "source": [
        "Below is the Boolean Oracle constructed for a pattern of length $m=2$ and a text of length $n=4$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        },
        "id": "4urpbwuU5JSv",
        "outputId": "f31dd0c4-2811-4789-cb36-069ddccec812"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                                                             \n",
              "j_0: ────■────────────────────────────────────────────■──────\n",
              "         │                                            │      \n",
              "j_1: ────┼─────────■─────────────────────■────────────┼──────\n",
              "         │         │     ┌────────┐      │            │      \n",
              "x_0: ────┼─────────┼─────┤0       ├──────┼────────────┼──────\n",
              "         │         │     │        │      │            │      \n",
              "x_1: ────┼─────────┼─────┤1       ├──────┼────────────┼──────\n",
              "     ┌───┴────┐┌───┴────┐│        │┌─────┴─────┐┌─────┴─────┐\n",
              "y_0: ┤0       ├┤0       ├┤2       ├┤0          ├┤0          ├\n",
              "     │        ││        ││        ││           ││           │\n",
              "y_1: ┤1       ├┤1       ├┤3 MATCH ├┤1          ├┤1          ├\n",
              "     │  ROT_1 ││  ROT_2 ││        ││  ROT_2_dg ││  ROT_1_dg │\n",
              "y_2: ┤2       ├┤2       ├┤        ├┤2          ├┤2          ├\n",
              "     │        ││        ││        ││           ││           │\n",
              "y_3: ┤3       ├┤3       ├┤        ├┤3          ├┤3          ├\n",
              "     └────────┘└────────┘│        │└───────────┘└───────────┘\n",
              "out: ────────────────────┤4       ├──────────────────────────\n",
              "                         └────────┘                          </pre>"
            ],
            "text/plain": [
              "                                                             \n",
              "j_0: ────■────────────────────────────────────────────■──────\n",
              "         │                                            │      \n",
              "j_1: ────┼─────────■─────────────────────■────────────┼──────\n",
              "         │         │     ┌────────┐      │            │      \n",
              "x_0: ────┼─────────┼─────┤0       ├──────┼────────────┼──────\n",
              "         │         │     │        │      │            │      \n",
              "x_1: ────┼─────────┼─────┤1       ├──────┼────────────┼──────\n",
              "     ┌───┴────┐┌───┴────┐│        │┌─────┴─────┐┌─────┴─────┐\n",
              "y_0: ┤0       ├┤0       ├┤2       ├┤0          ├┤0          ├\n",
              "     │        ││        ││        ││           ││           │\n",
              "y_1: ┤1       ├┤1       ├┤3 MATCH ├┤1          ├┤1          ├\n",
              "     │  ROT_1 ││  ROT_2 ││        ││  ROT_2_dg ││  ROT_1_dg │\n",
              "y_2: ┤2       ├┤2       ├┤        ├┤2          ├┤2          ├\n",
              "     │        ││        ││        ││           ││           │\n",
              "y_3: ┤3       ├┤3       ├┤        ├┤3          ├┤3          ├\n",
              "     └────────┘└────────┘│        │└───────────┘└───────────┘\n",
              "out: ────────────────────┤4       ├──────────────────────────\n",
              "                         └────────┘                          "
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "pattern_length = 2\n",
        "text_length = 4\n",
        "esm(pattern_length, text_length).draw(fold=255)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hVO0g4dYatch"
      },
      "source": [
        " Next, it is necessary to create a function that allows to transform the ESM operator into a Quantum Boolean Oracle."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "qLqdD_qE6Ayy"
      },
      "outputs": [],
      "source": [
        "def esm_oracle(m: int, n: int):\n",
        "    esm_circuit = esm(m, n)\n",
        "    return esm_circuit.to_gate(label='ESMO')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A0upUud07qHf"
      },
      "source": [
        "## The Grover Search for a Fixed Number of Occurrences\n",
        "\n",
        "The function below constructs a quantum gate representing the diffusion (reflection) operation which is used to amplify the amplitude of the desired solution state. The function takes one parameter: the number of qubits on which the diffusion operation is to be applied."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "4pepNhhxLrIH"
      },
      "outputs": [],
      "source": [
        "def diffuser(n: int) -> Gate:\n",
        "    qc = QuantumCircuit(n)\n",
        "\n",
        "    qc.h(range(n))\n",
        "    qc.x(range(n))\n",
        "\n",
        "    qc.h(n-1)\n",
        "    qc.mcx(list(range(n-1)), n-1)\n",
        "    qc.h(n-1)\n",
        "\n",
        "    qc.x(range(n))\n",
        "    qc.h(range(n))\n",
        "\n",
        "    return qc.to_gate(label='DIFF')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y4sVPKDFlHrM"
      },
      "source": [
        "The following function implements Grover's algorithm for solving a boolean function problem, where the objective is to search for a specific number of solutions satisfying a specified boolean function.<br/>\n",
        "The function first calculates the number of iterations of Grover's algorithm required based on the number of solutions $t$ to search for and the length $n$ of $y$. It prepares the control qubits in superposition and applies the necessary quantum gates to initialize $|x\\rangle$ and $|y\\rangle$ with their respective values. It then iteratively applies the ESM oracle and the DIFFUSION gate. After that, the function **verifies** the solution found, by measuring the control qubits $|j\\rangle$ and applying the ESM gate to check for an exact match."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "g6rQieZc0fSF"
      },
      "outputs": [],
      "source": [
        "def grover(esmo: Gate, t: int, x: str, y: str) -> QuantumCircuit:\n",
        "    n = len(y)\n",
        "    m = len(x)\n",
        "    logn = int(log2(n))\n",
        "    num_iterations = int(pi/4 * sqrt(n/t))\n",
        "\n",
        "    j_qr = QuantumRegister(logn, 'j')\n",
        "    x_qr = QuantumRegister(m, 'x')\n",
        "    y_qr = QuantumRegister(n, 'y')\n",
        "    out_qr = QuantumRegister(2, 'out')\n",
        "    out_cr = ClassicalRegister(logn+1, 'c')\n",
        "    qc = QuantumCircuit(j_qr, x_qr, y_qr, out_qr, out_cr)\n",
        "\n",
        "    qc.h(j_qr)\n",
        "    qc.x(out_qr[0])\n",
        "    qc.h(out_qr[0])\n",
        "\n",
        "    qc = qc.compose(init_register(x), x_qr[:])\n",
        "    qc = qc.compose(init_register(y), y_qr[:])\n",
        "\n",
        "    for _ in range(num_iterations):\n",
        "        qc = qc.compose(esmo)\n",
        "        qc = qc.compose(diffuser(logn))\n",
        "\n",
        "    qc.measure(j_qr, out_cr[:-1])\n",
        "    qc = qc.compose(esmo, j_qr[:] + x_qr[:] + y_qr[:] + [out_qr[1]])\n",
        "    qc.measure(out_qr[1], out_cr[-1])\n",
        "\n",
        "    return qc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-1zW_2IQRmi7"
      },
      "source": [
        "Below, we show the quantum circuit that is generated by the GroverESM function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 525
        },
        "id": "5g_6-kvJ0fSF",
        "outputId": "2910c0eb-3fec-46bb-c013-b1ee070c635f"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">       ┌───┐     ┌────────┐┌───────┐┌────────┐┌───────┐┌─┐      ┌────────┐   \n",
              "  j_0: ┤ H ├─────┤0       ├┤0      ├┤0       ├┤0      ├┤M├──────┤0       ├───\n",
              "       ├───┤     │        ││       ││        ││       │└╥┘┌─┐   │        │   \n",
              "  j_1: ┤ H ├─────┤1       ├┤1 DIFF ├┤1       ├┤1 DIFF ├─╫─┤M├───┤1       ├───\n",
              "       ├───┤     │        ││       ││        ││       │ ║ └╥┘┌─┐│        │   \n",
              "  j_2: ┤ H ├─────┤2       ├┤2      ├┤2       ├┤2      ├─╫──╫─┤M├┤2       ├───\n",
              "       ├───┤     │        │└───────┘│        │└───────┘ ║  ║ └╥┘│        │   \n",
              "  x_0: ┤ X ├─────┤3       ├─────────┤3       ├──────────╫──╫──╫─┤3       ├───\n",
              "       ├───┤     │        │         │        │          ║  ║  ║ │        │   \n",
              "  x_1: ┤ X ├─────┤4       ├─────────┤4       ├──────────╫──╫──╫─┤4       ├───\n",
              "       ├───┤     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_0: ┤ X ├─────┤5       ├─────────┤5       ├──────────╫──╫──╫─┤5       ├───\n",
              "       └───┘     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_1: ──────────┤6       ├─────────┤6       ├──────────╫──╫──╫─┤6       ├───\n",
              "       ┌───┐     │   ESMO │         │   ESMO │          ║  ║  ║ │        │   \n",
              "  y_2: ┤ X ├─────┤7       ├─────────┤7       ├──────────╫──╫──╫─┤7  ESMO ├───\n",
              "       └───┘     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_3: ──────────┤8       ├─────────┤8       ├──────────╫──╫──╫─┤8       ├───\n",
              "       ┌───┐     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_4: ┤ X ├─────┤9       ├─────────┤9       ├──────────╫──╫──╫─┤9       ├───\n",
              "       ├───┤     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_5: ┤ X ├─────┤10      ├─────────┤10      ├──────────╫──╫──╫─┤10      ├───\n",
              "       └───┘     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_6: ──────────┤11      ├─────────┤11      ├──────────╫──╫──╫─┤11      ├───\n",
              "                 │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_7: ──────────┤12      ├─────────┤12      ├──────────╫──╫──╫─┤12      ├───\n",
              "       ┌───┐┌───┐│        │         │        │          ║  ║  ║ │        │   \n",
              "out_0: ┤ X ├┤ H ├┤13      ├─────────┤13      ├──────────╫──╫──╫─┤        ├───\n",
              "       └───┘└───┘└────────┘         └────────┘          ║  ║  ║ │        │┌─┐\n",
              "out_1: ─────────────────────────────────────────────────╫──╫──╫─┤13      ├┤M├\n",
              "                                                        ║  ║  ║ └────────┘└╥┘\n",
              "  c: 4/═════════════════════════════════════════════════╩══╩══╩════════════╩═\n",
              "                                                        0  1  2            3 </pre>"
            ],
            "text/plain": [
              "       ┌───┐     ┌────────┐┌───────┐┌────────┐┌───────┐┌─┐      ┌────────┐   \n",
              "  j_0: ┤ H ├─────┤0       ├┤0      ├┤0       ├┤0      ├┤M├──────┤0       ├───\n",
              "       ├───┤     │        ││       ││        ││       │└╥┘┌─┐   │        │   \n",
              "  j_1: ┤ H ├─────┤1       ├┤1 DIFF ├┤1       ├┤1 DIFF ├─╫─┤M├───┤1       ├───\n",
              "       ├───┤     │        ││       ││        ││       │ ║ └╥┘┌─┐│        │   \n",
              "  j_2: ┤ H ├─────┤2       ├┤2      ├┤2       ├┤2      ├─╫──╫─┤M├┤2       ├───\n",
              "       ├───┤     │        │└───────┘│        │└───────┘ ║  ║ └╥┘│        │   \n",
              "  x_0: ┤ X ├─────┤3       ├─────────┤3       ├──────────╫──╫──╫─┤3       ├───\n",
              "       ├───┤     │        │         │        │          ║  ║  ║ │        │   \n",
              "  x_1: ┤ X ├─────┤4       ├─────────┤4       ├──────────╫──╫──╫─┤4       ├───\n",
              "       ├───┤     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_0: ┤ X ├─────┤5       ├─────────┤5       ├──────────╫──╫──╫─┤5       ├───\n",
              "       └───┘     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_1: ──────────┤6       ├─────────┤6       ├──────────╫──╫──╫─┤6       ├───\n",
              "       ┌───┐     │   ESMO │         │   ESMO │          ║  ║  ║ │        │   \n",
              "  y_2: ┤ X ├─────┤7       ├─────────┤7       ├──────────╫──╫──╫─┤7  ESMO ├───\n",
              "       └───┘     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_3: ──────────┤8       ├─────────┤8       ├──────────╫──╫──╫─┤8       ├───\n",
              "       ┌───┐     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_4: ┤ X ├─────┤9       ├─────────┤9       ├──────────╫──╫──╫─┤9       ├───\n",
              "       ├───┤     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_5: ┤ X ├─────┤10      ├─────────┤10      ├──────────╫──╫──╫─┤10      ├───\n",
              "       └───┘     │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_6: ──────────┤11      ├─────────┤11      ├──────────╫──╫──╫─┤11      ├───\n",
              "                 │        │         │        │          ║  ║  ║ │        │   \n",
              "  y_7: ──────────┤12      ├─────────┤12      ├──────────╫──╫──╫─┤12      ├───\n",
              "       ┌───┐┌───┐│        │         │        │          ║  ║  ║ │        │   \n",
              "out_0: ┤ X ├┤ H ├┤13      ├─────────┤13      ├──────────╫──╫──╫─┤        ├───\n",
              "       └───┘└───┘└────────┘         └────────┘          ║  ║  ║ │        │┌─┐\n",
              "out_1: ─────────────────────────────────────────────────╫──╫──╫─┤13      ├┤M├\n",
              "                                                        ║  ║  ║ └────────┘└╥┘\n",
              "  c: 4/═════════════════════════════════════════════════╩══╩══╩════════════╩═\n",
              "                                                        0  1  2            3 "
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = '11'\n",
        "y = '10101100'\n",
        "esmo = esm_oracle(len(x), len(y))\n",
        "grover(esmo, 1, x, y).draw(fold=255)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jit26aRHSYg2"
      },
      "source": [
        "Here is what $3$ different executions of the generated quantum circuit show."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 506
        },
        "id": "9Npv9a0JhfyB",
        "outputId": "77b74558-46b9-4c82-b6dc-b05d42e69691"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = '00'\n",
        "y = '01010101'\n",
        "esmo = esm_oracle(len(x), len(y))\n",
        "counts = run(grover(esmo, 1, x, y), 100)\n",
        "plot_histogram(counts, title=f'Search for {x} in {y} - 0 occurrence(s)')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 506
        },
        "id": "M8fU-7E4FqeE",
        "outputId": "8acd9b40-f2c8-4637-ba78-58cf15049067"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = '00'\n",
        "y = '11010011'\n",
        "esmo = esm_oracle(len(x), len(y))\n",
        "counts = run(grover(esmo, 1, x, y), 100)\n",
        "plot_histogram(counts, title=f'Search for {x} in {y} - 1 occurrence(s)')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 506
        },
        "id": "vaM3mpxEbDvt",
        "outputId": "de3b3716-eb89-48b1-a595-d546081e245b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = '00'\n",
        "y = '00111001'\n",
        "esmo = esm_oracle(len(x), len(y))\n",
        "counts = run(grover(esmo, 2, x, y), 100)\n",
        "plot_histogram(counts, title=f'Search for {x} in {y} - 2 occurrence(s)')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LBytEAHP70qe"
      },
      "source": [
        "## Solving the General Case\n",
        "\n",
        "In the general case, the value $t$ of occurrences is not known a priori and can only be obtained through a complex procedure based on the Quantum Phase Estimation. Since this algorithm works even if a correct $t^*$ estimate of $t$ is known, up to a small multiplicative error $1+\\varepsilon$, several approximate counting solutions have also been proposed. An effective practical solution for this problem has been recently given by **Venkateswaran** and **O'Donnell**. It consists in adaptively estimating $t$ by trying all the possible values in the range $[1.1^i]$ for $1\\leq i \\leq \\log_{1.1}(N/2)$, until a solution is found or, alternatively, responding negatively if no solutions are found. This approach requires a  total number of Grover iterations which is still $\\tilde{O}(\\sqrt{n})$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "jvNCnfk90fSG"
      },
      "outputs": [],
      "source": [
        "def search(x: str, y: str) -> int:\n",
        "    m = len(x)\n",
        "    n = len(y)\n",
        "    esmo = esm_oracle(m, n)\n",
        "\n",
        "    for t in range(1, int(n/2) + 1):\n",
        "\n",
        "        print('Trying with t =', t)\n",
        "        results = run(grover(esmo, t, x, y), 1)\n",
        "        results = list(results.keys())[0]\n",
        "        outcome = int(results[0])\n",
        "        position = int(results[1:], 2)\n",
        "\n",
        "        if outcome: return position\n",
        "        else: print('Pattern not found in position', position)\n",
        "\n",
        "    return -1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TeDIDNcrU2I7"
      },
      "source": [
        "<h2><b>Now come on, let's try it!</b></h2>\n",
        "Just remember that:\n",
        "\n",
        "- $x$ is the pattern of length $m$.\n",
        "- $y$ is the text of length $n \\geq m$.\n",
        "- Both $x$ and $y$ must be binary strings."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0e48A6OjeOXd",
        "outputId": "0812f83b-ae30-41b5-f0f1-7f240c6f53bd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter the value of x: 00\n",
            "Enter the value of y: 10100101\n",
            "\n",
            "Trying with t = 1\n",
            "Pattern occurrence found in position 3\n"
          ]
        }
      ],
      "source": [
        "x = input('Enter the value of x: ')\n",
        "y = input('Enter the value of y: ')\n",
        "\n",
        "if len(x) > len(y):\n",
        "    raise ValueError('The length of x must be shorter than the length of y.')\n",
        "\n",
        "if not all(c in '01' for c in x):\n",
        "    raise ValueError('The pattern must be a binary string.')\n",
        "\n",
        "if not all(c in '01' for c in y):\n",
        "    raise ValueError('The text must be a binary string.')\n",
        "\n",
        "print('')\n",
        "position = search(x, y)\n",
        "\n",
        "if position >= 0: print('Pattern occurrence found in position', str(position))\n",
        "else: print('Pattern occurrence not found.')"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.11.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}