Algorithm for Planted Noisy kXOR

dev_tools/qualtran_dev_tools/notebook_specs.py

@@ -95,6 +95,7 @@
 import qualtran.bloqs.gf_poly_arithmetic.gf2_poly_add
 import qualtran.bloqs.gf_poly_arithmetic.gf2_poly_add_k
 import qualtran.bloqs.gf_poly_arithmetic.gf_poly_split_and_join
+import qualtran.bloqs.hamiltonian_simulation.guided_hamiltonian
 import qualtran.bloqs.hamiltonian_simulation.hamiltonian_simulation_by_gqsp
 import qualtran.bloqs.mcmt.and_bloq
 import qualtran.bloqs.mcmt.controlled_via_and
@@ -875,6 +876,13 @@
             qualtran.bloqs.optimization.k_xor_sat.kikuchi_block_encoding._KIKUCHI_HAMILTONIAN_DOC
         ],
     ),
+    NotebookSpecV2(
+        title='Algorithm: Planted Noisy kXOR',
+        module=qualtran.bloqs.optimization.k_xor_sat.planted_noisy_kxor,
+        bloq_specs=[
+            qualtran.bloqs.optimization.k_xor_sat.planted_noisy_kxor._PLANTED_NOISY_KXOR_DOC
+        ],
+    ),
 ]
 
 # --------------------------------------------------------------------------
@@ -983,6 +991,14 @@
             qualtran.bloqs.hamiltonian_simulation.hamiltonian_simulation_by_gqsp._Hamiltonian_Simulation_by_GQSP_DOC
         ],
     ),
+    NotebookSpecV2(
+        title='Guided Hamiltonian Problem',
+        module=qualtran.bloqs.hamiltonian_simulation.guided_hamiltonian,
+        bloq_specs=[
+            qualtran.bloqs.hamiltonian_simulation.guided_hamiltonian._GUIDED_HAMILTONIAN_DOC,
+            qualtran.bloqs.hamiltonian_simulation.guided_hamiltonian._GUIDED_HAMILTONIAN_PHASE_ESTIMATION_DOC,
+        ],
+    ),
 ]
 
 NB_BY_SECTION = [

docs/bloqs/index.rst

@@ -161,6 +161,7 @@ Bloqs Library
     optimization/k_xor_sat/kikuchi_adjacency_list.ipynb
     optimization/k_xor_sat/kikuchi_adjacency_matrix.ipynb
     optimization/k_xor_sat/kikuchi_block_encoding.ipynb
+    optimization/k_xor_sat/planted_noisy_kxor.ipynb
 
 .. toctree::
     :maxdepth: 2
@@ -180,3 +181,4 @@ Bloqs Library
     state_preparation/state_preparation_via_rotation.ipynb
     qsp/generalized_qsp.ipynb
     hamiltonian_simulation/hamiltonian_simulation_by_gqsp.ipynb
+    hamiltonian_simulation/guided_hamiltonian.ipynb

qualtran/bloqs/hamiltonian_simulation/__init__.py

@@ -11,3 +11,4 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
+from .guided_hamiltonian import GuidedHamiltonian, GuidedHamiltonianPhaseEstimation

qualtran/bloqs/hamiltonian_simulation/guided_hamiltonian.ipynb

@@ -0,0 +1,308 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a84f2ea4",
+   "metadata": {
+    "cq.autogen": "title_cell"
+   },
+   "source": [
+    "# Guided Hamiltonian Problem"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7faaaff",
+   "metadata": {
+    "cq.autogen": "top_imports"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran import Bloq, CompositeBloq, BloqBuilder, Signature, Register\n",
+    "from qualtran import QBit, QInt, QUInt, QAny\n",
+    "from qualtran.drawing import show_bloq, show_call_graph, show_counts_sigma\n",
+    "from typing import *\n",
+    "import numpy as np\n",
+    "import sympy\n",
+    "import cirq"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "155994ae",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.bloq_doc.md"
+   },
+   "source": [
+    "## `GuidedHamiltonian`\n",
+    "Solve the Guided (Sparse) Hamiltonian Problem.\n",
+    "\n",
+    "Definition 4.8 (modified to accept any block-encoding):\n",
+    "In the Guided Hamiltonian problem we are given the following as input:\n",
+    "\n",
+    "1. A $(\\sqrt{2} s, \\cdot, 0)$-block-encoding of a Hamiltonian $H$ such that $\\|H\\|_\\max \\le s$.\n",
+    "2. A unitary program that prepares $|\\Psi\\rangle|0^A\\rangle$.\n",
+    "3. Parameters $\\lambda \\in [-\\Lambda, \\Lambda]$, $\\alpha \\in (0, 1)$, $\\gamma \\in (0, 1]$.\n",
+    "\n",
+    "and we should output\n",
+    "\n",
+    "- YES (1) if $\\| \\Pi_{\\ge \\lambda} (H) |\\Psi\\rangle \\| \\ge \\gamma$\n",
+    "- NO (0) if $\\|H\\| \\le (1 - \\alpha) \\lambda$\n",
+    "\n",
+    "Note that the above drops the sparsity requirement, and accepts any\n",
+    "$(\\alpha_H, \\cdot, \\cdot)$-block-encoding of $H$.\n",
+    "In the sparse Hamiltonian case, $\\alpha_H = s$ (where $s$ is the sparsity).\n",
+    "\n",
+    "Algorithm (Theorem 4.9):\n",
+    "    This uses phase estimation on the block-encoding of $e^{iHt}$, and then uses\n",
+    "    amplitude amplification to increase the success probability to $1 - o(1)$.\n",
+    "\n",
+    "We instead directly do phase-estimation on the qubitized walk operator for $H$.\n",
+    "\n",
+    "#### Parameters\n",
+    " - `hamiltonian`: the block-encoding of $H$\n",
+    " - `guiding_state`: the unitary that prepares $|\\Psi\\rangle$\n",
+    " - `lambd`: parameter $\\lambda$\n",
+    " - `alpha`: parameter $\\alpha$\n",
+    " - `gamma`: parameter $\\gamma$ \n",
+    "\n",
+    "#### References\n",
+    " - [Quartic quantum speedups for planted inference](https://arxiv.org/abs/2406.19378v1). Section 4.2 \"Guided Sparse Hamiltonian Problem\".\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3d433e9",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.bloq_doc.py"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran.bloqs.hamiltonian_simulation import GuidedHamiltonian"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b15c049e",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.example_instances.md"
+   },
+   "source": [
+    "### Example Instances"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f52ecab",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.guided_hamiltonian_symb"
+   },
+   "outputs": [],
+   "source": [
+    "import sympy\n",
+    "\n",
+    "from qualtran.bloqs.optimization.k_xor_sat import GuidingState, KikuchiHamiltonian, KXorInstance\n",
+    "from qualtran.bloqs.state_preparation.black_box_prepare import BlackBoxPrepare\n",
+    "from qualtran.symbolics import ceil, log2\n",
+    "\n",
+    "n, k, m, c = sympy.symbols(\"n k m c\", positive=True, integer=True)\n",
+    "zeta = sympy.symbols(r\"\\zeta\", positive=True)\n",
+    "\n",
+    "inst_guide = KXorInstance.symbolic(n, (1 - zeta) * m, k, max_rhs=2)\n",
+    "inst_solve = KXorInstance.symbolic(n, zeta * m, k, max_rhs=2)\n",
+    "l = c * k\n",
+    "s = l * ceil(log2(n))\n",
+    "\n",
+    "Psi = GuidingState(inst_guide, l)\n",
+    "H = KikuchiHamiltonian(inst_solve, c * k, s)\n",
+    "\n",
+    "lambd, alpha, gamma = sympy.symbols(r\"\\lambda \\alpha \\gamma\", positive=True, real=True)\n",
+    "guided_hamiltonian_symb = GuidedHamiltonian(H, BlackBoxPrepare(Psi), lambd, alpha, gamma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "06377668",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.graphical_signature.md"
+   },
+   "source": [
+    "#### Graphical Signature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3c32914",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.graphical_signature.py"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran.drawing import show_bloqs\n",
+    "show_bloqs([guided_hamiltonian_symb],\n",
+    "           ['`guided_hamiltonian_symb`'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c4949b3",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.call_graph.md"
+   },
+   "source": [
+    "### Call Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "85d0c98d",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonian.call_graph.py"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran.resource_counting.generalizers import ignore_split_join\n",
+    "guided_hamiltonian_symb_g, guided_hamiltonian_symb_sigma = guided_hamiltonian_symb.call_graph(max_depth=1, generalizer=ignore_split_join)\n",
+    "show_call_graph(guided_hamiltonian_symb_g)\n",
+    "show_counts_sigma(guided_hamiltonian_symb_sigma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35fd7bde",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.bloq_doc.md"
+   },
+   "source": [
+    "## `GuidedHamiltonianPhaseEstimation`\n",
+    "Phase estimation subroutine for the Guided Hamiltonian Problem.\n",
+    "\n",
+    "Implements the algorithm $U_\\text{PE}$ used in the Guided Hamiltonian Problem.\n",
+    "See the bloq `GuidedHamiltonian` for the full problem definition.\n",
+    "\n",
+    "#### References\n",
+    " - [Quartic quantum speedups for planted inference](https://arxiv.org/abs/2406.19378v1). Section 4.2 \"Guided Sparse Hamiltonian Problem\".\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04b36a18",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.bloq_doc.py"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran.bloqs.hamiltonian_simulation import GuidedHamiltonianPhaseEstimation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79ebea83",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.example_instances.md"
+   },
+   "source": [
+    "### Example Instances"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f01c6434",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.guided_phase_estimate_symb"
+   },
+   "outputs": [],
+   "source": [
+    "import sympy\n",
+    "\n",
+    "from qualtran.bloqs.optimization.k_xor_sat import GuidingState, KikuchiHamiltonian, KXorInstance\n",
+    "from qualtran.bloqs.state_preparation.black_box_prepare import BlackBoxPrepare\n",
+    "from qualtran.symbolics import ceil, log2\n",
+    "\n",
+    "n, k, c = sympy.symbols(\"n k c\", positive=True, integer=True)\n",
+    "m_guide, m_solve = sympy.symbols(\"m_1 m_2\", positive=True, integer=True)\n",
+    "\n",
+    "inst_guide = KXorInstance.symbolic(n, m_guide, k, max_rhs=2)\n",
+    "inst_solve = KXorInstance.symbolic(n, m_solve, k, max_rhs=2)\n",
+    "l = c * k\n",
+    "s = l * ceil(log2(n))\n",
+    "\n",
+    "Psi = GuidingState(inst_guide, l)\n",
+    "H = KikuchiHamiltonian(inst_solve, c * k, s)\n",
+    "\n",
+    "eps, delta = sympy.symbols(r\"\\epsilon_{PE} \\delta_{PE}\", positive=True, real=True)\n",
+    "guided_phase_estimate_symb = GuidedHamiltonianPhaseEstimation(\n",
+    "    H, BlackBoxPrepare(Psi), eps, delta\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aaff689f",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.graphical_signature.md"
+   },
+   "source": [
+    "#### Graphical Signature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1913a0c3",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.graphical_signature.py"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran.drawing import show_bloqs\n",
+    "show_bloqs([guided_phase_estimate_symb],\n",
+    "           ['`guided_phase_estimate_symb`'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a72035ec",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.call_graph.md"
+   },
+   "source": [
+    "### Call Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ce30cc4",
+   "metadata": {
+    "cq.autogen": "GuidedHamiltonianPhaseEstimation.call_graph.py"
+   },
+   "outputs": [],
+   "source": [
+    "from qualtran.resource_counting.generalizers import ignore_split_join\n",
+    "guided_phase_estimate_symb_g, guided_phase_estimate_symb_sigma = guided_phase_estimate_symb.call_graph(max_depth=1, generalizer=ignore_split_join)\n",
+    "show_call_graph(guided_phase_estimate_symb_g)\n",
+    "show_counts_sigma(guided_phase_estimate_symb_sigma)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}