aztechacks_2024_challenge-functions.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mnshmnsh/Classiq-AztecHacks-2024-Quantum-Hackathon/blob/main/Copy_of_aztechacks_2024_functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NmfQEwtuPIDG"
      },
      "source": [
        "# AztecHacks 2024: Quantum Challenge - Implement & Innovate with Classiq\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import classiq\n",
        "classiq.authenticate()\n"
      ],
      "metadata": {
        "id": "_RtKdA5uRnmt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3793315e-5157-4743-8e03-77b3aa6e3849"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Your user code: PRQL-XDTC\n",
            "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=PRQL-XDTC\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ghBG32FQPIDa"
      },
      "outputs": [],
      "source": [
        "from classiq import *\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BGaTmP2wPIDc"
      },
      "source": [
        "\n",
        "---\n",
        "\n",
        "### `inplace_square`\n",
        "**What it computes:**\n",
        "- This function computes the square of the input quantum number `x` and stores the result in `y`.\n",
        "- **Mathematical description:** $ y = x^2 $\n",
        "\n",
        "**Parameters:**\n",
        "- `y`, `x`: Quantum numbers (`QNum`).\n",
        "\n",
        "---\n",
        "\n",
        "### `inplace_linear`\n",
        "**What it computes:**\n",
        "- Computes a linear transformation of the input quantum number `x` using constants `a` and `b`, storing the result in `y`.\n",
        "- **Mathematical description:** $ y = ax + b $\n",
        "\n",
        "**Parameters:**\n",
        "- `a`, `b`: Classical integers (`CInt`).\n",
        "- `x`, `y`: Quantum numbers (`QNum`).\n",
        "\n",
        "---\n",
        "\n",
        "### `inplace_quadratic`\n",
        "**What it computes:**\n",
        "- Computes the quadratic polynomial of the input quantum number `x` with coefficients `a`, `b`, and `c`, storing the result in `y`.\n",
        "- **Mathematical description:** $ y = ax^2 + bx + c $\n",
        "\n",
        "**Parameters:**\n",
        "- `a`, `b`, `c`: Classical integers (`CInt`).\n",
        "- `x`, `y`: Quantum numbers (`QNum`).\n",
        "\n",
        "---\n",
        "\n",
        "### `inplace_cubic`\n",
        "**What it computes:**\n",
        "- Computes the cubic of the input quantum number `x` using coefficient `a`, storing the result in `y`.\n",
        "- **Mathematical description:** $ y = ax^3 $\n",
        "\n",
        "**Parameters:**\n",
        "- `a`: A classical integer (`CInt`).\n",
        "- `x` , `y`: Quantum numbers (`QNum`).\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "### `inplace_exponential`\n",
        "**What it computes:**\n",
        "- Computes the exponential of the input quantum number `x` raised to a power `b` and scaled by `a`, storing the result in `y`.\n",
        "- **Mathematical description:** $ y = ax^b $\n",
        "\n",
        "**Parameters:**\n",
        "- `a`, `b`: Classical integers (`CInt`).\n",
        "- `x`, `y`: Quantum numbers (`QNum`).\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Oi5XKUUUPIDf"
      },
      "outputs": [],
      "source": [
        "\n",
        "@qfunc\n",
        "def inplace_square(y:Output[QNum],x:QNum) -> None:\n",
        "    # Perform the exponentiation\n",
        "    # Assign the result to y\n",
        "    y |= x ** 2\n",
        "\n",
        "@qfunc\n",
        "def inplace_linear(y:Output[QNum], a:CInt, b:CInt,x:QNum) -> None:\n",
        "    # Perform the multiplication followed by the addition\n",
        "    y |= (a * x) + b\n",
        "\n",
        "@qfunc\n",
        "def inplace_quadratic(y:Output[QNum],a:CInt, b:CInt, c:CInt,x:QNum) -> None:\n",
        "    # Perform the exponentiation, then the multiplications\n",
        "    # The additions come last\n",
        "    y |= (a * (x ** 2)) + (b * x) + c\n",
        "\n",
        "@qfunc\n",
        "def inplace_cubic(y:Output[QNum],a:CInt,x:QNum) -> None:\n",
        "    # Perform the exponentiation, then multiplication\n",
        "    # Scale the result by a\n",
        "    y |= a * (x ** 3)\n",
        "\n",
        "@qfunc\n",
        "def inplace_exponential(y:Output[QNum],a:CInt, b:CInt,x:QNum) -> None:\n",
        "    # Perform the exponentiation, then multiplication\n",
        "    # Scale the result by a\n",
        "    y |= a * (x ** b)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EDej5D4pPIDi"
      },
      "source": [
        "---\n",
        "\n",
        "### `discrete_log_oracle`\n",
        "**What it computes:**\n",
        "- A quantum function that is part of a larger quantum algorithm for computing the discrete logarithm. It is an oracle used in the quantum discrete logarithm algorithm.\n",
        "- **Mathematical description:** Not explicitly given, but part of an oracle computation in quantum algorithms.\n",
        "\n",
        "**Parameters:**\n",
        "- `g`, `x`, `N`: Classical integers (`CInt`), parameters of the discrete logarithm problem.\n",
        "- `x1`, `x2`: Quantum arrays (`QArray[QBit]`), used in the computation.\n",
        "- `func_res`: An output quantum array (`Output[QArray[QBit]]`) where the result of the computation is stored.\n",
        "\n",
        "---\n",
        "\n",
        "### `inplace_discrete_logarithm`\n",
        "**What it computes:**\n",
        "- Implements a quantum algorithm for computing the discrete logarithm of `x` base `g` modulo `N`.\n",
        "- **Mathematical description:** Not explicitly detailed, but involves quantum Fourier transforms and other quantum operations.\n",
        "\n",
        "**Parameters:**\n",
        "- `g`, `x`, `N`, `order`: Classical integers (`CInt`), parameters of the discrete logarithm problem and its order.\n",
        "- `x1`, `x2`: Outputs that are quantum arrays (`Output[QArray[QBit]]`), used in the computation.\n",
        "- `func_res`: An output quantum array (`Output[QArray[QBit]]`) where the result of the computation is stored.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lgHiAK_HPIDl"
      },
      "outputs": [],
      "source": [
        "from classiq.qmod.symbolic import ceiling, log\n",
        "\n",
        "@qfunc\n",
        "def discrete_log_oracle(\n",
        "    g: CInt,\n",
        "    x: CInt,\n",
        "    N: CInt,\n",
        "    x1: QArray[QBit],\n",
        "    x2: QArray[QBit],\n",
        "    func_res: Output[QArray[QBit]],\n",
        "):\n",
        "\n",
        "    #pass\n",
        "\n",
        "    allocate(ceiling(log(N, 2)), func_res)\n",
        "\n",
        "    inplace_prepare_int(1, func_res)\n",
        "    modular_exp(N, x, func_res, x1)\n",
        "    modular_exp(N, g, func_res, x2)\n",
        "\n",
        "@qfunc\n",
        "def inplace_discrete_logarithm(g: CInt,\n",
        "    x: CInt,\n",
        "    N: CInt,\n",
        "    order: CInt,\n",
        "    x1: Output[QArray[QBit]],\n",
        "    x2: Output[QArray[QBit]],\n",
        "    func_res: Output[QArray[QBit]],\n",
        "):\n",
        "    #pass\n",
        "    reg_len = ceiling(log(order, 2))\n",
        "    allocate(reg_len, x1)\n",
        "    allocate(reg_len, x2)\n",
        "\n",
        "    hadamard_transform(x1)\n",
        "    hadamard_transform(x2)\n",
        "\n",
        "    discrete_log_oracle(g, x, N, order, x1, x2, func_res)\n",
        "\n",
        "    invert(lambda: qft(x1))\n",
        "    invert(lambda: qft(x2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2cUJOfEGPIDn"
      },
      "source": [
        "---\n",
        "\n",
        "\n",
        "### `equality_oracle`\n",
        "**What it computes:**\n",
        "- This function compares two quantum numbers `x_1` and `x_2` for equality, and stores the result in `y`.\n",
        "- **Mathematical description:** $ y = (x_1 == x_2) $ (This function sets `y` to a value indicating whether `x_1` and `x_2` are equal.)\n",
        "\n",
        "**Parameters:**\n",
        "- `y`: A quantum number (`QNum`) where the result is stored.\n",
        "- `x_1`, `x_2`: Quantum numbers (`QNum`) that are compared.\n",
        "\n",
        "---\n",
        "\n",
        "### `inplace_sum`\n",
        "**What it computes:**\n",
        "- Computes the sum of two quantum numbers `y` and `x`, storing the result back in `y`.\n",
        "- **Mathematical description:** $ y = y + x $\n",
        "\n",
        "**Parameters:**\n",
        "- `y`: A quantum number (`QNum`) that holds the initial value and where the result is stored.\n",
        "- `x`: A quantum number (`QNum`) that is added to `y`.\n",
        "\n",
        "---\n",
        "\n",
        "### `sum_of_squares`\n",
        "**What it computes:**\n",
        "- Calculates the sum of the squares of two quantum numbers `x_1` and `x_2`, storing the result in `y`.\n",
        "- **Mathematical description:** $ y = x_1^2 + x_2^2 $\n",
        "- This function involves additional operations like allocating temporary quantum numbers `temp_1` and `temp_2` and performing transformations on them.\n",
        "\n",
        "**Parameters:**\n",
        "- `y`: A quantum number (`QNum`) where the result is stored.\n",
        "- `x_1`, `x_2`: Quantum numbers (`QNum`) whose squares are computed and summed.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_He1H_p9PIDq"
      },
      "outputs": [],
      "source": [
        "@qfunc\n",
        "def equality_oracle(y:Output[QNum],x_1:QNum,x_2:QNum) -> None:\n",
        "    # Check if the equality is true or false and store the result in y\n",
        "    y |= (x_1 == x_2)\n",
        "\n",
        "@qfunc\n",
        "def inplace_sum(yout:Output[QNum],y: QNum, x:QNum) -> None:\n",
        "    # Compute the sum of y and x, storing the result back in yout\n",
        "    yout |= y + x\n",
        "\n",
        "@qfunc\n",
        "def sum_of_squares(y:Output[QNum],x_1:QNum,x_2:QNum) -> None:\n",
        "    # Compute the squares of x_1 and x_2\n",
        "    # Compute the sum of the squares and store the result in y\n",
        "    y |= (x_1 ** 2) + (x_2 ** 2)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This is to test the above defined functions.\n",
        "# Only one function may be active at any one time.\n",
        "# To test a function uncomment the appropriate line.\n",
        "# Keep all other functions commented.\n",
        "\n",
        "from classiq import Output, QNum, create_model, prepare_int, qfunc\n",
        "\n",
        "@qfunc\n",
        "def main(y1: Output[QNum], x1: Output[QNum],x2:Output[QNum]) -> None:\n",
        "\n",
        "    prepare_int(3,x1)\n",
        "    #inplace_square(y1,x1)\n",
        "    a = 2\n",
        "    b = 2\n",
        "    #inplace_linear(y1,a,b,x1)\n",
        "    c = 5\n",
        "    #inplace_quadratic(y1,a,b,c,x1)\n",
        "    #inplace_cubic(y1,a,x1)\n",
        "    #inplace_exponential(y1,a,b,x1)\n",
        "    prepare_int(4,x2)\n",
        "    #equality_oracle(y1,x1,x2)\n",
        "    tmp = QNum('tmp')\n",
        "    prepare_int(4,tmp)\n",
        "    #inplace_sum(y1,tmp,x1)\n",
        "    sum_of_squares(y1,x1,x2)\n",
        "\n",
        "# Create the quantum model\n",
        "qmod = create_model(main)\n",
        "\n",
        "from classiq import execute, synthesize, write_qmod\n",
        "\n",
        "# Write the quantum model to a file\n",
        "write_qmod(qmod, \"inplace_square_example\")\n",
        "\n",
        "# Synthesize the quantum program\n",
        "qprog = synthesize(qmod)\n",
        "\n",
        "# Execute the quantum program and get the result\n",
        "result = execute(qprog).result()[0].value\n",
        "print(result.parsed_counts)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w8bfuueYybAi",
        "outputId": "af9d2613-4b4d-45de-95f4-d1a93174e9de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'y1': 25.0, 'x1': 3.0, 'x2': 4.0}: 2048]\n"
          ]
        }
      ]
    }
  ],
  "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.11.8"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}