diff --git a/community/womanium/assignments/Weronika_Golletz_hw4.ipynb b/community/womanium/assignments/Weronika_Golletz_hw4.ipynb new file mode 100644 index 00000000..8c438859 --- /dev/null +++ b/community/womanium/assignments/Weronika_Golletz_hw4.ipynb @@ -0,0 +1,265 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6.12 Assignment: Advanced Algorithms Design\n", + "\n", + "Design the quantum walk operator for the case of a line with 16 modes.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Short description of a graph:**\n", + "\n", + "The described structure is a path graph consisting of 16 nodes aligned sequentially and linked in a linear topology. Each vertex connects to its immediate adjacent vertices, creating a series of edges \n", + "(0,1),(1,2),…,(14,15)." + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quantum walk algorithms: short introduction\n", + "\n", + "Quantum walk algorithms are the quantum analogs of classical random walks and serve as fundamental building blocks in the design of quantum algorithms. In quantum computing, these algorithms exploit quantum superposition and entanglement to explore multiple paths simultaneously, significantly accelerating tasks like search algorithms and graph traversal. This capability allows quantum walks to perform certain computations much faster than their classical counterparts, providing a potential edge in solving complex computational problems.\n", + "\n", + "In the code below, we focus on two major steps of the quantum walk algorithm (discrete-time):\n", + "1. Coin Operation: Apply a coin operator to the coin register. This quantum operation creates a combination of possible directions in which the walker can move. We will use the C operator to describe the movement probabilities.\n", + "\n", + "2. Shift Operation: Apply a shift operator to the walker's position based on the state of the coin register. This operator moves the walker to new positions depending on the current state of the coin register. The quantum walker evolves under this shift operator, leading to a spread over the graph or structure that the algorithm is exploring. We will use the S operato to execute the movement.\n", + "\n", + "One step of discrete-time quantum walk is describe by the unitary operator SC.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coin operator\n", + "\n", + "$$ C := \\sum_{j\\in V} |j\\rangle\\langle j| \\otimes (2|\\partial_j\\rangle \\langle \\partial_j| - \\mathbb{1}) $$\n", + "\n", + "\n", + "### Phase kickback\n", + "let us assume that we know the $U_j$ operator that creates the state $|\\partial_j\\rangle$, i.e. $U_j |0 \\rangle = |\\partial_j\\rangle$.\n", + "\n", + "Then $(2|\\partial_j\\rangle \\langle \\partial_j| - \\mathbb{1}) = U_j (2 |0\\rangle\\langle 0| - \\mathbb{1})U_j^{\\dagger}$, where in the braket is the phase kickback (quantum primitieves) encoded:\n", + "\n", + "$$ (2 |0\\rangle\\langle0| - \\mathbb{1})|x\\rangle = (-1)^{x\\neq 0 } |x \\rangle $$" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "### Implementing of the phase kickback\n", + "\n", + "# Prepare the |-> state\n", + "@qfunc\n", + "def prepare_minus(x: QBit):\n", + " X(x)\n", + " H(x)\n", + "\n", + "# Check the phase\n", + "@qfunc\n", + "def diffuzer_oracle(aux: Output[QNum],x:QNum):\n", + " aux^=(x!=0)\n", + " \n", + "# Apply phase kickback\n", + "@qfunc\n", + "def zero_diffuzer(x: QNum):\n", + " aux = QNum('aux')\n", + " allocate(1,aux)\n", + " within_apply(compute=lambda: prepare_minus(aux),\n", + " action=lambda: diffuzer_oracle)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define a C (coin) operator\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare a C operator; |j><0|-1)U_j^dagger\n", + "def W_iteration(i:int,vertices: QNum, adjacent_vertices:QNum):\n", + " nodes = 2**size\n", + " prob = [0]*nodes\n", + " if i == 0:\n", + " prob[i+1] = 1\n", + " elif i == (nodes-1):\n", + " prob[nodes-2] = 1\n", + " else:\n", + " prob[i-1] = 0.5\n", + " prob[i+1] = 0.5\n", + " print(f'State={i}, prob vec ={prob}')\n", + " \n", + " control(ctrl=vertices==i,\n", + " operand=lambda: within_apply(\n", + " compute= lambda: inplace_prepare_state(probabilities=prob, bound=0.01, target=adjacent_vertices),\n", + " action= lambda: zero_diffuzer(adjacent_vertices)))\n", + "\n", + "# Apply the C operator to all vertices; sum_{j in V} W_iteration\n", + "@qfunc \n", + "def W_operator(vertices:QNum, adjacent_vertices: QNum):\n", + " for i in range(2**size):\n", + " W_iteration(i,vertices,adjacent_vertices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Shift operator\n", + "\n", + "$$S : = \\sum_{(j,k)\\in E} |j,k \\rangle \\langle k,j| $$\n", + "\n", + "Connections for 1D chain without periodic boundary conditions:\n", + "1. The first node and the last have just one connection, 0-1 and 14-15, respectively,\n", + "for system with 16 nodes.\n", + "2. Each node between the first and last has two connections, (i-1)-i and i-(i+1)." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "# Swap the QArray bit by bit |j,k>,|1>,...,|15>. Then apply the coin operator and shift operator. This two functions together constitude a one step in the quantum walk algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "State=0, prob vec =[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=1, prob vec =[0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=2, prob vec =[0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=3, prob vec =[0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=4, prob vec =[0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=5, prob vec =[0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=6, prob vec =[0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "State=7, prob vec =[0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0, 0]\n", + "State=8, prob vec =[0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0, 0]\n", + "State=9, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0, 0]\n", + "State=10, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0, 0]\n", + "State=11, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0, 0]\n", + "State=12, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0, 0]\n", + "State=13, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5, 0]\n", + "State=14, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0.5]\n", + "State=15, prob vec =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]\n", + "Opening: https://platform.classiq.io/circuit/6691eae1-7316-4e9d-80f5-d8fa88e4122a?version=0.43.3\n" + ] + } + ], + "source": [ + "size = 4 # we need 4 qubits to simulate a graph with 16 nodes; 2^4=16\n", + "\n", + "@qfunc \n", + "def main(vertices:Output[QNum], adjacent_vertices:Output[QNum]):\n", + "\n", + " allocate(size,vertices)\n", + " hadamard_transform(vertices)\n", + " allocate(size,adjacent_vertices)\n", + "\n", + " W_operator(vertices,adjacent_vertices) # apply coin operator\n", + " S_operator(vertices,adjacent_vertices) # apply shift operator\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Classiq", + "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.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}