Bloqs arithmetic and sorting

cirq_qubitization/bloq_algos/__init__.py

@@ -1 +1 @@
-from . import and_bloq, basic_gates
+from . import and_bloq, arithmetic, basic_gates, sorting

cirq_qubitization/bloq_algos/arithmetic.ipynb

@@ -0,0 +1,253 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "40368a5b",
+   "metadata": {
+    "cq.autogen": "title_cell"
+   },
+   "source": [
+    "# Arithmetic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "410926b9",
+   "metadata": {
+    "cq.autogen": "top_imports"
+   },
+   "outputs": [],
+   "source": [
+    "import cirq\n",
+    "import numpy as np\n",
+    "import cirq_qubitization\n",
+    "import cirq_ft\n",
+    "import cirq_ft.infra.testing as cq_testing\n",
+    "from cirq_qubitization.jupyter_tools import display_gate_and_compilation, show_bloq\n",
+    "from typing import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b92171ba",
+   "metadata": {
+    "cq.autogen": "_make_add.md"
+   },
+   "source": [
+    "## `Add`\n",
+    "An n-bit addition gate.\n",
+    "\n",
+    "Implements $U|a\\rangle|b\\rangle \\rightarrow |a\\rangle|a+b\\rangle$ using $4n - 4 T$ gates.\n",
+    "\n",
+    "#### Parameters\n",
+    " - `bitsize`: Number of bits used to represent each integer. Must be large enough to hold the result in the output register of a + b. \n",
+    "\n",
+    "Registers:\n",
+    " - a: A bitsize-sized input register (register a above).\n",
+    " - b: A bitsize-sized input/output register (register b above).\n",
+    "\n",
+    "#### References\n",
+    "[Halving the cost of quantum addition](https://arxiv.org/abs/1709.06648)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f930d4ff",
+   "metadata": {
+    "cq.autogen": "_make_add.py"
+   },
+   "outputs": [],
+   "source": [
+    "from cirq_qubitization.bloq_algos.arithmetic import Add\n",
+    "\n",
+    "bloq = Add(bitsize=4)\n",
+    "show_bloq(bloq)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b20c805",
+   "metadata": {
+    "cq.autogen": "_make_product.md"
+   },
+   "source": [
+    "## `Product`\n",
+    "Compute the product of an `n` and `m` bit integer.\n",
+    "\n",
+    "Implements $U|a\\rangle|b\\rangle|0\\rangle -\\rightarrow\n",
+    "|a\\rangle|b\\rangle|a\\times b\\rangle$ using $2nm-n$ Toffolis.\n",
+    "\n",
+    "#### Parameters\n",
+    " - `a_bitsize`: Number of bits used to represent the first integer.\n",
+    " - `b_bitsize`: Number of bits used to represent the second integer. \n",
+    "\n",
+    "Registers:\n",
+    " - a: a_bitsize-sized input register.\n",
+    " - b: b_bitsize-sized input register.\n",
+    " - result: A 2*max(a_bitsize, b_bitsize) bit-sized output register to store\n",
+    "    the result a*b.\n",
+    "\n",
+    "#### References\n",
+    "[Fault-Tolerant Quantum Simulations of Chemistry in First Quantization](https://arxiv.org/abs/2105.12767) pg 81 gives a Toffoli complexity for multiplying two numbers.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "877b583b",
+   "metadata": {
+    "cq.autogen": "_make_product.py"
+   },
+   "outputs": [],
+   "source": [
+    "from cirq_qubitization.bloq_algos.arithmetic import Product\n",
+    "\n",
+    "bloq = Product(a_bitsize=4, b_bitsize=6)\n",
+    "show_bloq(bloq)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f50caf16",
+   "metadata": {
+    "cq.autogen": "_make_square.md"
+   },
+   "source": [
+    "## `Square`\n",
+    "Square an n-bit number.\n",
+    "\n",
+    "Implements $U|a\\rangle|0\\rangle \\rightarrow |a\\rangle|a^2\\rangle$ using $4n - 4 T$ gates.\n",
+    "\n",
+    "#### Parameters\n",
+    " - `bitsize`: Number of bits used to represent the integer to be squared. The result is stored in a register of size 2*bitsize. \n",
+    "\n",
+    "Registers:\n",
+    " - a: A bitsize-sized input register (register a above).\n",
+    " - result: A 2-bitsize-sized input/ouput register.\n",
+    "\n",
+    "#### References\n",
+    "[Fault-Tolerant Quantum Simulations of Chemistry in First Quantization](https://arxiv.org/abs/2105.12767). pg 76 for Toffoli complexity.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "633eb3ba",
+   "metadata": {
+    "cq.autogen": "_make_square.py"
+   },
+   "outputs": [],
+   "source": [
+    "from cirq_qubitization.bloq_algos.arithmetic import Square\n",
+    "\n",
+    "bloq = Square(bitsize=8)\n",
+    "show_bloq(bloq)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18e2cca7",
+   "metadata": {
+    "cq.autogen": "_make_sum_of_squares.md"
+   },
+   "source": [
+    "## `SumOfSquares`\n",
+    "Compute the sum of squares of k n-bit numbers.\n",
+    "\n",
+    "Implements $U|a\\rangle|b\\rangle\\dots k\\rangle|0\\rangle \\rightarrow\n",
+    "    |a\\rangle|b\\rangle\\dots|k\\rangle|a^2+b^2+\\dots k^2\\rangle$ using\n",
+    "    $4 k n^2 T$ gates.\n",
+    "\n",
+    "#### Parameters\n",
+    " - `bitsize`: Number of bits used to represent each of the k integers.\n",
+    " - `k`: The number of integers we want to square. \n",
+    "\n",
+    "Registers:\n",
+    " - input: k n-bit registers.\n",
+    " - result: 2 * bitsize + 1 sized output register.\n",
+    "\n",
+    "#### References\n",
+    "[Fault-Tolerant Quantum Simulations of Chemistry in First Quantization](https://arxiv.org/abs/2105.12767) pg 80 give a Toffoli complexity for squaring.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95d0069d",
+   "metadata": {
+    "cq.autogen": "_make_sum_of_squares.py"
+   },
+   "outputs": [],
+   "source": [
+    "from cirq_qubitization.bloq_algos.arithmetic import SumOfSquares\n",
+    "\n",
+    "bloq = SumOfSquares(bitsize=8, k=4)\n",
+    "show_bloq(bloq)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20639a7a",
+   "metadata": {
+    "cq.autogen": "_make_greater_than.md"
+   },
+   "source": [
+    "## `GreaterThan`\n",
+    "Compare two n-bit integers.\n",
+    "\n",
+    "Implements $U|a\\rangle|b\\rangle|0\\rangle \\rightarrow\n",
+    "|a\\rangle|b\\rangle|a > b\\rangle$ using $8n T$  gates.\n",
+    "\n",
+    "\n",
+    "#### Parameters\n",
+    " - `bitsize`: Number of bits used to represent the two integers a and b. \n",
+    "\n",
+    "Registers:\n",
+    " - a: n-bit-sized input registers.\n",
+    " - b: n-bit-sized input registers.\n",
+    " - result: A single bit output register to store the result of A > B.\n",
+    "\n",
+    "#### References\n",
+    "[Improved techniques for preparing eigenstates of fermionic Hamiltonians](https://www.nature.com/articles/s41534-018-0071-5#additional-information), Comparison Oracle from SI: Appendix 2B (pg 3)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "af66690c",
+   "metadata": {
+    "cq.autogen": "_make_greater_than.py"
+   },
+   "outputs": [],
+   "source": [
+    "from cirq_qubitization.bloq_algos.arithmetic import GreaterThan\n",
+    "\n",
+    "bloq = GreaterThan(bitsize=4)\n",
+    "show_bloq(bloq)"
+   ]
+  }
+ ],
+ "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.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}