challenge_ym_aztechacks_2024_functions (1).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NmfQEwtuPIDG"
      },
      "source": [
        "# AztecHacks 2024: Quantum Challenge - Implement & Innovate with Classiq.\n",
        "#  10 functions\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vAp4WSlsPIDT"
      },
      "outputs": [],
      "source": [
        "!pip install -U classiq"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import classiq\n",
        "classiq.authenticate()"
      ],
      "metadata": {
        "id": "_RtKdA5uRnmt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f598f844-8836-4b9a-c778-062d3f569197"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Your user code: NRQV-HVMJ\n",
            "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=NRQV-HVMJ\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",
        "\n",
        "    # Create a temporary quantum number\n",
        "    temp = QNum('temp')\n",
        "\n",
        "    # Perform the multiplication\n",
        "    temp |= x ** 2\n",
        "\n",
        "    # Assign the result to y\n",
        "    y |= temp\n",
        "\n",
        "@qfunc\n",
        "def inplace_linear(y:Output[QNum], a:CInt, b:CInt,x:QNum):\n",
        "    #pass\n",
        "    temp = QNum('temp')\n",
        "    temp |= x\n",
        "    y |= (a * temp) + b\n",
        "\n",
        "@qfunc\n",
        "def inplace_quadratic(y:Output[QNum],a:CInt, b:CInt, c:CInt,x:QNum):\n",
        "    #pass\n",
        "    temp = QNum('temp')\n",
        "    temp |= x ** 2\n",
        "    y |= (a * temp) + (b * x) + c\n",
        "\n",
        "@qfunc\n",
        "def inplace_cubic(y:Output[QNum],a:CInt,x:QNum):\n",
        "    #pass\n",
        "\n",
        "    temp = QNum('temp')\n",
        "    temp |= x ** 3\n",
        "    y |= a * temp\n",
        "\n",
        "@qfunc\n",
        "def inplace_exponential(y:Output[QNum],a:CInt, b:CInt,x:QNum):\n",
        "    #pass\n",
        "\n",
        "    # Create a temporary quantum number\n",
        "    temp = QNum('temp')\n",
        "    temp |= x ** b\n",
        "    y |= a * temp\n",
        "\n",
        "\n",
        "    # Scale the result by a"
      ]
    },
    {
      "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",
        "    #pass\n",
        "\n",
        "    # Create a temporary quantum number\n",
        "    temp = QNum('temp')\n",
        "\n",
        "    # Check if the result is zero and store the result in y\n",
        "    temp |= (x_1 == x_2)\n",
        "\n",
        "    y |= temp\n",
        "\n",
        "@qfunc\n",
        "def inplace_sum(yout:Output[QNum],y: QNum, x:QNum):\n",
        "    #pass\n",
        "    #y = y + x\n",
        "    temp = QNum('temp')\n",
        "    temp |= y\n",
        "    tmpx = QNum('tmpx')\n",
        "    tmpx |= temp + x\n",
        "    #prepare_int(tmpx,y)\n",
        "\n",
        "    # Compute the sum of y and x, storing the result back in y\n",
        "\n",
        "    yout |= tmpx\n",
        "\n",
        "@qfunc\n",
        "def sum_of_squares(y:Output[QNum],x_1:QNum,x_2:QNum):\n",
        "    #pass\n",
        "    # Allocate temporary quantum numbers\n",
        "    temp_1 = QNum('temp_1')\n",
        "    temp_2 = QNum('temp_2')\n",
        "    temp_1 |= x_1 ** 2\n",
        "    temp_2 |= x_2 ** 2\n",
        "    # Compute the squares of x_1 and x_2\n",
        "\n",
        "\n",
        "    # Compute the sum of the squares and store the result in y\n",
        "    y |= temp_1 + temp_2"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#from tempfile import TMP_MAX\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",
        "    # Prepare the initial value of x\n",
        "\n",
        "    #y1=QNum('y1')\n",
        "    #x1=QNum('x1')\n",
        "    x=QNum('x')\n",
        "    prepare_int(3,x1)\n",
        "    #inplace_square(y1,x1)\n",
        "\n",
        "    a = 2\n",
        "    b = 2\n",
        "\n",
        "    #inplace_linear(y1,a,b,x1)\n",
        "\n",
        "    c = 5\n",
        "    #inplace_quadratic(y1,a,b,c,x1)\n",
        "\n",
        "    #inplace_cubic(y1,a,x1)\n",
        "    #inplace_exponential(y1,a,b,x1)\n",
        "\n",
        "    prepare_int(4,x2)\n",
        "\n",
        "    #equality_oracle(y1,x1,x2)\n",
        "    tmp = QNum('tmp')\n",
        "    prepare_int(4,tmp)\n",
        "\n",
        "    inplace_sum(y1,tmp,x1)\n",
        "    #y1 |= tmp\n",
        "    #sum_of_squares(y1,x1,x2)\n",
        "\n",
        "\n",
        "    # Store the result in y\n",
        "\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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w8bfuueYybAi",
        "outputId": "98b1d561-e083-4b3c-d147-18d998e32117"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'y1': 7.0, 'x1': 3.0, 'x2': 4.0}: 2048]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Generic imports\n",
        "from classiq import QArray, QBit, allocate, create_model"
      ],
      "metadata": {
        "id": "ZYlPrRArRM-g"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "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": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}