diff --git a/README.md b/README.md
index 8a32aab3..87e5b26e 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,7 @@ Running notebooks locally requires additional dependencies located in [notebooks
 | Quantum PCA | [Quantum_Principal_Component_Analysis.ipynb](notebooks/advanced_algorithms/Quantum_Principal_Component_Analysis.ipynb) | [He2022](https://ieeexplore.ieee.org/document/9669030) |
 | QMC | [Quantum_Computing_Quantum_Monte_Carlo.ipynb](notebooks/advanced_algorithms/Quantum_Computing_Quantum_Monte_Carlo.ipynb) | [Motta2018](https://wires.onlinelibrary.wiley.com/doi/10.1002/wcms.1364), [Peruzzo2014](https://www.nature.com/articles/ncomms5213) |
 | Adaptive Shot Allocation | [2_Adaptive_Shot_Allocation.ipynb](notebooks/advanced_algorithms/adaptive_shot_allocation/2_Adaptive_Shot_Allocation.ipynb) | [Shlosberg2023](https://doi.org/10.22331/q-2023-01-26-906) |
+| HHL Algorithm | [HHL_Algorithm.ipynb](notebooks/advanced_algorithms/HHL_Algorithm.ipynb) | [Harrow2009](https://arxiv.org/abs/0811.3171) |
 
 
 | Auxiliary functions | Notebook |
diff --git a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb
new file mode 100644
index 00000000..9eb76a71
--- /dev/null
+++ b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb
@@ -0,0 +1,936 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "46327740-1403-42ca-be4c-452ec15137df",
+   "metadata": {},
+   "source": [
+    "# Harrow-Hassidim-Lloyd (HHL) Algorithm\n",
+    "\n",
+    "This notebook demonstrates the **HHL algorithm** for solving systems of linear equations $A\\vec{x} = \\vec{b}$ on a quantum computer using the Amazon Braket SDK.\n",
+    "\n",
+    "The HHL algorithm, introduced by Aram Harrow, Avinatan Hassidim, and Seth Lloyd in 2009 [1], is one of the fundamental quantum algorithms alongside Shor's factoring algorithm and Grover's search algorithm. It can provide an **exponential speedup** over classical methods for certain classes of problems. However, the overall speedup depends on the efficiency of state preparation and readout, which can be problem-dependent.\n",
+    "\n",
+    "## Overview\n",
+    "\n",
+    "Given an $N \\times N$ Hermitian matrix $A$ and a unit vector $\\vec{b}$, the HHL algorithm prepares a quantum state $|x\\rangle$ whose amplitudes are proportional to the entries of $\\vec{x} = A^{-1}\\vec{b}$. The algorithm cannot efficiently output the full solution vector $\\vec{x}$ directly, but allows one to efficiently estimate summary statistics such as $\\vec{x}^T M \\vec{x}$ for some operator $M$.\n",
+    "\n",
+    "### Algorithm Steps\n",
+    "\n",
+    "The HHL algorithm consists of four main steps:\n",
+    "\n",
+    "1. **State Preparation**: Encode the vector $\\vec{b}$ into a quantum state $|b\\rangle$\n",
+    "2. **Quantum Phase Estimation (QPE)**: Decompose $|b\\rangle$ in the eigenbasis of $A$ and estimate the eigenvalues $\\lambda_j$\n",
+    "3. **Controlled Rotation**: Apply a rotation conditioned on each eigenvalue to encode $C/\\lambda_j$ into an ancilla qubit\n",
+    "4. **Inverse QPE**: Uncompute the eigenvalue register\n",
+    "\n",
+    "After post-selecting on the ancilla qubit measuring $|1\\rangle$, the remaining state is proportional to:\n",
+    "\n",
+    "$$|x\\rangle = A^{-1}|b\\rangle = \\sum_{j=1}^{N} \\beta_j \\lambda_j^{-1} |u_j\\rangle$$\n",
+    "\n",
+    "where $|u_j\\rangle$ are the eigenvectors of $A$ and $\\beta_j$ are the coefficients of $|b\\rangle$ in the eigenbasis.\n",
+    "\n",
+    "### Complexity\n",
+    "\n",
+    "For sparse, well-conditioned matrices, HHL runs in $O(\\log(N) \\kappa^2)$ time, where $\\kappa$ is the condition number of $A$. This is an exponential speedup compared to the best classical algorithm, which runs in $O(N\\kappa)$.\n",
+    "\n",
+    "### Caveats\n",
+    "\n",
+    "- $A$ must be Hermitian (if not, it can be embedded in a larger Hermitian system)\n",
+    "- $\\vec{b}$ must be efficiently preparable as a quantum state\n",
+    "- The exponential speedup only applies when summary statistics of $\\vec{x}$ are needed, not the full solution\n",
+    "- The matrix should be sparse and well-conditioned for optimal performance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "339d0d20-7afd-4210-8630-38b3b561dea7",
+   "metadata": {},
+   "source": [
+    "## Understanding the Circuit Components\n",
+    "\n",
+    "Let's walk through each component of the HHL circuit in more detail.\n",
+    "\n",
+    "### 1. State Preparation\n",
+    "\n",
+    "The vector $\\vec{b}$ is encoded as a quantum state $|b\\rangle$ on the input qubit. For a 2-element vector $\\vec{b} = (b_0, b_1)^T$, this is done using an $R_y$ rotation:\n",
+    "\n",
+    "$$|b\\rangle = \\cos(\\theta/2)|0\\rangle + \\sin(\\theta/2)|1\\rangle$$\n",
+    "\n",
+    "where $\\theta = 2\\arccos(b_0)$ for real vectors.\n",
+    "\n",
+    "### 2. Quantum Phase Estimation (QPE)\n",
+    "\n",
+    "QPE decomposes $|b\\rangle$ in the eigenbasis of $A$ and estimates eigenvalues. It uses:\n",
+    "- Hadamard gates on clock qubits to create superposition\n",
+    "- Controlled $U^{2^k} = e^{iAt \\cdot 2^k}$ operations (Hamiltonian simulation)\n",
+    "- Inverse QFT on the clock register\n",
+    "\n",
+    "After QPE, the state is approximately:\n",
+    "$$\\sum_j \\beta_j |u_j\\rangle|\\tilde{\\lambda}_j\\rangle$$\n",
+    "\n",
+    "### 3. Controlled Rotation\n",
+    "\n",
+    "For each eigenvalue $\\lambda_j$ stored in the clock register, we perform a controlled $R_y$ rotation on the ancilla qubit with angle $\\theta_j = 2\\arcsin(C/\\lambda_j)$:\n",
+    "\n",
+    "$$|\\tilde{\\lambda}_j\\rangle|0\\rangle_a \\rightarrow |\\tilde{\\lambda}_j\\rangle\\left(\\sqrt{1 - \\frac{C^2}{\\lambda_j^2}}|0\\rangle_a + \\frac{C}{\\lambda_j}|1\\rangle_a\\right)$$\n",
+    "\n",
+    "### 4. Inverse QPE\n",
+    "\n",
+    "The inverse QPE uncomputes the clock register, returning it to $|0\\rangle^{\\otimes n}$.\n",
+    "After post-selecting on the ancilla measuring $|1\\rangle$, the input qubit is in the state $|x\\rangle \\propto A^{-1}|b\\rangle$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79d70716-f526-4c12-bf6f-ac4922a4d254",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "First, let's import the necessary libraries and the HHL module from the Braket Algorithm Library."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "193335f0-8584-49c7-b214-25cb04ed8993",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:10.969942Z",
+     "iopub.status.busy": "2026-02-26T22:09:10.969713Z",
+     "iopub.status.idle": "2026-02-26T22:09:17.582785Z",
+     "shell.execute_reply": "2026-02-26T22:09:17.581333Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "from braket.devices import LocalSimulator\n",
+    "from braket.experimental.algorithms.hhl import (\n",
+    "    get_hhl_results,\n",
+    "    hhl_circuit,\n",
+    "    run_hhl,\n",
+    ")\n",
+    "\n",
+    "# magic word for producing visualizations in notebook\n",
+    "%matplotlib inline\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48e440ee-c0aa-4ba1-b5be-c9fd4ea10fc3",
+   "metadata": {},
+   "source": [
+    "## Example 1: Solving a Simple Diagonal System\n",
+    "\n",
+    "Let's start with a simple example. Consider the system $A\\vec{x} = \\vec{b}$ where:\n",
+    "\n",
+    "$$A = \\begin{pmatrix} 1 & 0 \\\\ 0 & 2 \\end{pmatrix}, \\quad \\vec{b} = \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$$\n",
+    "\n",
+    "The classical solution is trivially $\\vec{x} = \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$.\n",
+    "\n",
+    "This diagonal case is instructive because the eigenvalues are simply the diagonal elements, making it easy to understand how QPE encodes them and how the controlled rotation inverts them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d0552d6b-f73a-410d-8250-d678e0838412",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:17.586417Z",
+     "iopub.status.busy": "2026-02-26T22:09:17.585240Z",
+     "iopub.status.idle": "2026-02-26T22:09:17.641977Z",
+     "shell.execute_reply": "2026-02-26T22:09:17.640922Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Matrix A:\n",
+      "[[1.+0.j 0.+0.j]\n",
+      " [0.+0.j 2.+0.j]]\n",
+      "Vector b: [1.+0.j 0.+0.j]\n",
+      "Eigenvalues of A: [1. 2.]\n",
+      "Condition number: 2.00\n",
+      "\n",
+      "Classical solution: [1.+0.j 0.+0.j]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Define the system\n",
+    "A1 = np.array([[1, 0], [0, 2]], dtype=complex)\n",
+    "b1 = np.array([1, 0], dtype=complex)\n",
+    "\n",
+    "# Print eigenvalues\n",
+    "eigenvalues, eigenvectors = np.linalg.eigh(A1)\n",
+    "print(f\"Matrix A:\\n{A1}\")\n",
+    "print(f\"Vector b: {b1}\")\n",
+    "print(f\"Eigenvalues of A: {eigenvalues}\")\n",
+    "print(f\"Condition number: {max(abs(eigenvalues)) / min(abs(eigenvalues)):.2f}\")\n",
+    "print(f\"\\nClassical solution: {np.linalg.solve(A1, b1)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2fb16e34-8c8a-4f0d-b3f5-46928e2e84b4",
+   "metadata": {},
+   "source": [
+    "### Build and Visualize the HHL Circuit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12cab98f-3905-4507-9962-2ad30a420c93",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:17.644677Z",
+     "iopub.status.busy": "2026-02-26T22:09:17.644471Z",
+     "iopub.status.idle": "2026-02-26T22:09:17.804234Z",
+     "shell.execute_reply": "2026-02-26T22:09:17.802171Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "HHL Circuit for Example 1:\n",
+      "Number of qubits: 4\n",
+      "  - Clock qubits: q0, q1 (QPE register)\n",
+      "  - Input qubit: q2 (encodes |b>)\n",
+      "  - Ancilla qubit: q3 (for eigenvalue inversion)\n",
+      "Circuit depth: 45\n",
+      "Number of instructions: 68\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Build the HHL circuit\n",
+    "hhl_circ1 = hhl_circuit(A1, b1, num_clock_qubits=2)\n",
+    "\n",
+    "print(\"HHL Circuit for Example 1:\")\n",
+    "print(f\"Number of qubits: {hhl_circ1.qubit_count}\")\n",
+    "print(\"  - Clock qubits: q0, q1 (QPE register)\")\n",
+    "print(\"  - Input qubit: q2 (encodes |b>)\")\n",
+    "print(\"  - Ancilla qubit: q3 (for eigenvalue inversion)\")\n",
+    "print(f\"Circuit depth: {hhl_circ1.depth}\")\n",
+    "print(f\"Number of instructions: {len(hhl_circ1.instructions)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2fd6b070-9ff1-4e3d-b057-e454d125c7e6",
+   "metadata": {},
+   "source": [
+    "### Run on the Local Simulator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "34ca956d-5750-4ed1-9dd1-c84a7c7550dd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:17.808217Z",
+     "iopub.status.busy": "2026-02-26T22:09:17.807956Z",
+     "iopub.status.idle": "2026-02-26T22:09:18.002640Z",
+     "shell.execute_reply": "2026-02-26T22:09:18.001362Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running HHL Algorithm...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "HHL Run Complete!\n",
+      "Matrix A:\n",
+      "[[1.+0.j 0.+0.j]\n",
+      " [0.+0.j 2.+0.j]]\n",
+      "\n",
+      "Vector b: [1.+0.j 0.+0.j]\n",
+      "\n",
+      "Classical solution x = A^(-1)b: [1.+0.j 0.+0.j]\n",
+      "Classical solution (normalized): [1.+0.j 0.+0.j]\n",
+      "Classical probabilities |x_i|^2: [1. 0.]\n",
+      "\n",
+      "Total measurement shots: 10000\n",
+      "Post-selection success shots: 4877\n",
+      "Success probability: 0.4877\n",
+      "\n",
+      "Post-selected counts: {'0': 4877}\n",
+      "Quantum solution probabilities: {'0': 1.0}\n",
+      "\n",
+      "Fidelity with classical solution: 1.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run on local simulator\n",
+    "device = LocalSimulator()\n",
+    "print(\"Running HHL Algorithm...\")\n",
+    "task1 = run_hhl(hhl_circ1, device, shots=10000)\n",
+    "print(\"HHL Run Complete!\")\n",
+    "\n",
+    "# Get and display results\n",
+    "results1 = get_hhl_results(task1, A1, b1, num_clock_qubits=2, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b79bf43-5d36-4ea0-bf51-5171bb5592c2",
+   "metadata": {},
+   "source": [
+    "### Visualize the Results\n",
+    "\n",
+    "Let's compare the quantum solution (from post-selected measurements) with the classical solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c13cf144-dec2-4425-9812-280723977963",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:18.008059Z",
+     "iopub.status.busy": "2026-02-26T22:09:18.007624Z",
+     "iopub.status.idle": "2026-02-26T22:09:18.504998Z",
+     "shell.execute_reply": "2026-02-26T22:09:18.503397Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_hhl_comparison(results, title=\"HHL Algorithm Results\"):\n",
+    "    \"\"\"Plot comparison between quantum and classical solutions.\"\"\"\n",
+    "    fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n",
+    "\n",
+    "    # Plot 1: Raw measurement counts\n",
+    "    counts = results[\"measurement_counts\"]\n",
+    "    sorted_counts = dict(sorted(counts.items()))\n",
+    "    axes[0].bar(sorted_counts.keys(), sorted_counts.values(), color=\"steelblue\", alpha=0.8)\n",
+    "    axes[0].set_xlabel(\"Bitstring (clock | input | ancilla)\")\n",
+    "    axes[0].set_ylabel(\"Counts\")\n",
+    "    axes[0].set_title(\"Raw Measurement Counts\")\n",
+    "    axes[0].tick_params(axis=\"x\", rotation=90)\n",
+    "\n",
+    "    # Plot 2: Post-selected solution probabilities vs classical\n",
+    "    quantum_probs = [\n",
+    "        results[\"solution_state_probabilities\"].get(\"0\", 0),\n",
+    "        results[\"solution_state_probabilities\"].get(\"1\", 0),\n",
+    "    ]\n",
+    "    classical_probs = list(results[\"classical_probabilities\"])\n",
+    "\n",
+    "    x = np.arange(2)\n",
+    "    width = 0.35\n",
+    "    axes[1].bar(\n",
+    "        x - width / 2, quantum_probs, width, label=\"Quantum (HHL)\", color=\"coral\", alpha=0.8\n",
+    "    )\n",
+    "    axes[1].bar(\n",
+    "        x + width / 2, classical_probs, width, label=\"Classical\", color=\"steelblue\", alpha=0.8\n",
+    "    )\n",
+    "    axes[1].set_xlabel(\"Solution Component\")\n",
+    "    axes[1].set_ylabel(\"Probability |x_i|²\")\n",
+    "    axes[1].set_title(f\"Solution Comparison (Fidelity: {results['fidelity']:.4f})\")\n",
+    "    axes[1].set_xticks(x)\n",
+    "    axes[1].set_xticklabels([\"|0⟩\", \"|1⟩\"])\n",
+    "    axes[1].legend()\n",
+    "\n",
+    "    # Plot 3: Success probability pie chart\n",
+    "    success_rate = results[\"success_probability\"]\n",
+    "    axes[2].pie(\n",
+    "        [success_rate, 1 - success_rate],\n",
+    "        labels=[\"Success\\n(ancilla=|1⟩)\", \"Failure\\n(ancilla=|0⟩)\"],\n",
+    "        colors=[\"mediumseagreen\", \"lightcoral\"],\n",
+    "        autopct=\"%1.1f%%\",\n",
+    "        startangle=90,\n",
+    "    )\n",
+    "    axes[2].set_title(\"Post-Selection Success Rate\")\n",
+    "\n",
+    "    fig.suptitle(title, fontsize=14, fontweight=\"bold\")\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "plot_hhl_comparison(results1, \"Example 1: Diagonal Matrix A = diag(1, 2), b = [1, 0]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc50a6b5-4499-4842-8a91-d9f232f2a163",
+   "metadata": {},
+   "source": [
+    "## Example 2: Solving a Non-Diagonal Hermitian System\n",
+    "\n",
+    "Now let's try a more interesting example with off-diagonal elements:\n",
+    "\n",
+    "$$A = \\begin{pmatrix} 2 & 1 \\\\ 1 & 2 \\end{pmatrix}, \\quad \\vec{b} = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$$\n",
+    "\n",
+    "This matrix has eigenvalues $\\lambda_1 = 1$ and $\\lambda_2 = 3$, with condition number $\\kappa = 3$.\n",
+    "\n",
+    "The classical solution is:\n",
+    "$$\\vec{x} = A^{-1}\\vec{b} = \\frac{1}{3\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "38f2a703-76c1-470a-8cbe-e8ee235c147e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:18.511924Z",
+     "iopub.status.busy": "2026-02-26T22:09:18.511696Z",
+     "iopub.status.idle": "2026-02-26T22:09:18.565894Z",
+     "shell.execute_reply": "2026-02-26T22:09:18.564756Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Matrix A:\n",
+      "[[2.+0.j 1.+0.j]\n",
+      " [1.+0.j 2.+0.j]]\n",
+      "Vector b: [0.70710678+0.j 0.70710678+0.j]\n",
+      "Eigenvalues of A: [1. 3.]\n",
+      "Condition number: 3.00\n",
+      "\n",
+      "Classical solution: [0.23570226+0.j 0.23570226+0.j]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Define the system\n",
+    "A2 = np.array([[2, 1], [1, 2]], dtype=complex)\n",
+    "b2 = np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=complex)\n",
+    "\n",
+    "# Print eigenvalues\n",
+    "eigenvalues2, eigenvectors2 = np.linalg.eigh(A2)\n",
+    "print(f\"Matrix A:\\n{A2}\")\n",
+    "print(f\"Vector b: {b2}\")\n",
+    "print(f\"Eigenvalues of A: {eigenvalues2}\")\n",
+    "print(f\"Condition number: {max(abs(eigenvalues2)) / min(abs(eigenvalues2)):.2f}\")\n",
+    "print(f\"\\nClassical solution: {np.linalg.solve(A2, b2)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2694eec7-1db9-4f7b-8f2d-1415f03f4258",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:18.568864Z",
+     "iopub.status.busy": "2026-02-26T22:09:18.568339Z",
+     "iopub.status.idle": "2026-02-26T22:09:19.384102Z",
+     "shell.execute_reply": "2026-02-26T22:09:19.382964Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running HHL Algorithm for Example 2...\n",
+      "HHL Run Complete!\n",
+      "Matrix A:\n",
+      "[[2.+0.j 1.+0.j]\n",
+      " [1.+0.j 2.+0.j]]\n",
+      "\n",
+      "Vector b: [0.70710678+0.j 0.70710678+0.j]\n",
+      "\n",
+      "Classical solution x = A^(-1)b: [0.23570226+0.j 0.23570226+0.j]\n",
+      "Classical solution (normalized): [0.70710678+0.j 0.70710678+0.j]\n",
+      "Classical probabilities |x_i|^2: [0.5 0.5]\n",
+      "\n",
+      "Total measurement shots: 10000\n",
+      "Post-selection success shots: 4684\n",
+      "Success probability: 0.4684\n",
+      "\n",
+      "Post-selected counts: {'1': 2345, '0': 2339}\n",
+      "Quantum solution probabilities: {'1': 0.5006404782237404, '0': 0.4993595217762596}\n",
+      "\n",
+      "Fidelity with classical solution: 1.0000\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Build and run HHL\n",
+    "hhl_circ2 = hhl_circuit(A2, b2, num_clock_qubits=2)\n",
+    "\n",
+    "print(\"Running HHL Algorithm for Example 2...\")\n",
+    "task2 = run_hhl(hhl_circ2, device, shots=10000)\n",
+    "print(\"HHL Run Complete!\")\n",
+    "\n",
+    "results2 = get_hhl_results(task2, A2, b2, num_clock_qubits=2, verbose=True)\n",
+    "\n",
+    "plot_hhl_comparison(results2, \"Example 2: A = [[2,1],[1,2]], b = [1/√2, 1/√2]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92b305d0-61de-41e7-af0b-75596a32214e",
+   "metadata": {},
+   "source": [
+    "## Example 3: Effect of the Condition Number\n",
+    "\n",
+    "The condition number $\\kappa = \\lambda_{\\max}/\\lambda_{\\min}$ is a key parameter affecting HHL performance.\n",
+    "Let's explore how different condition numbers affect the success probability and solution quality.\n",
+    "\n",
+    "We'll use the matrix:\n",
+    "$$A = \\begin{pmatrix} \\lambda_1 & 0 \\\\ 0 & \\lambda_2 \\end{pmatrix}$$\n",
+    "\n",
+    "with $\\lambda_1 = 1$ and varying $\\lambda_2$ to change the condition number."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f820a731-4ad3-467b-b7ca-97c84b78188c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:19.386184Z",
+     "iopub.status.busy": "2026-02-26T22:09:19.385978Z",
+     "iopub.status.idle": "2026-02-26T22:09:20.512551Z",
+     "shell.execute_reply": "2026-02-26T22:09:20.511084Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Condition Number Analysis\n",
+      "============================================================\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "κ = 1: Fidelity = 1.0000, Success Prob = 0.5346\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "κ = 2: Fidelity = 0.8918, Success Prob = 0.4895\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "κ = 3: Fidelity = 0.8104, Success Prob = 0.4595\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "κ = 4: Fidelity = 0.7231, Success Prob = 0.1680\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Test with different condition numbers\n",
+    "b_test = np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=complex)\n",
+    "condition_numbers = [1, 2, 3, 4]\n",
+    "fidelities = []\n",
+    "success_probs = []\n",
+    "\n",
+    "print(\"Condition Number Analysis\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "for kappa in condition_numbers:\n",
+    "    A_test = np.array([[1, 0], [0, kappa]], dtype=complex)\n",
+    "    circ = hhl_circuit(A_test, b_test, num_clock_qubits=2)\n",
+    "    task = run_hhl(circ, device, shots=10000)\n",
+    "    results = get_hhl_results(task, A_test, b_test, num_clock_qubits=2)\n",
+    "\n",
+    "    fidelities.append(results[\"fidelity\"])\n",
+    "    success_probs.append(results[\"success_probability\"])\n",
+    "\n",
+    "    print(\n",
+    "        f\"κ = {kappa}: Fidelity = {results['fidelity']:.4f}, \"\n",
+    "        f\"Success Prob = {results['success_probability']:.4f}\"\n",
+    "    )\n",
+    "\n",
+    "# Plot\n",
+    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "\n",
+    "ax1.plot(condition_numbers, fidelities, \"o-\", color=\"coral\", linewidth=2, markersize=8)\n",
+    "ax1.set_xlabel(\"Condition Number κ\")\n",
+    "ax1.set_ylabel(\"Fidelity\")\n",
+    "ax1.set_title(\"Solution Fidelity vs Condition Number\")\n",
+    "ax1.grid(True, alpha=0.3)\n",
+    "ax1.set_ylim([0, 1.05])\n",
+    "\n",
+    "ax2.plot(condition_numbers, success_probs, \"s-\", color=\"steelblue\", linewidth=2, markersize=8)\n",
+    "ax2.set_xlabel(\"Condition Number κ\")\n",
+    "ax2.set_ylabel(\"Success Probability\")\n",
+    "ax2.set_title(\"Post-Selection Success vs Condition Number\")\n",
+    "ax2.grid(True, alpha=0.3)\n",
+    "ax2.set_ylim([0, 1.05])\n",
+    "\n",
+    "plt.suptitle(\"Effect of Condition Number on HHL Performance\", fontsize=14, fontweight=\"bold\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "063cca65-3ba7-4d48-a887-293eae9d2613",
+   "metadata": {},
+   "source": [
+    "## Example 4: Varying the Input Vector\n",
+    "\n",
+    "Let's fix the matrix and explore how different input vectors $\\vec{b}$ affect the solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "40d94b2a-036a-4ae1-bb84-0fd375d9b6eb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:20.517092Z",
+     "iopub.status.busy": "2026-02-26T22:09:20.516718Z",
+     "iopub.status.idle": "2026-02-26T22:09:22.105854Z",
+     "shell.execute_reply": "2026-02-26T22:09:22.104777Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n",
+      "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "A4 = np.array([[2, 1], [1, 2]], dtype=complex)\n",
+    "\n",
+    "# Different b vectors (all normalized)\n",
+    "test_vectors = [\n",
+    "    (np.array([1, 0], dtype=complex), \"|0⟩\"),\n",
+    "    (np.array([0, 1], dtype=complex), \"|1⟩\"),\n",
+    "    (np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=complex), \"|+⟩\"),\n",
+    "    (np.array([1 / np.sqrt(2), -1 / np.sqrt(2)], dtype=complex), \"|−⟩\"),\n",
+    "]\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n",
+    "\n",
+    "for idx, (b_vec, label) in enumerate(test_vectors):\n",
+    "    ax = axes[idx // 2][idx % 2]\n",
+    "\n",
+    "    circ = hhl_circuit(A4, b_vec, num_clock_qubits=2)\n",
+    "    task = run_hhl(circ, device, shots=10000)\n",
+    "    results = get_hhl_results(task, A4, b_vec, num_clock_qubits=2)\n",
+    "\n",
+    "    quantum_probs = [\n",
+    "        results[\"solution_state_probabilities\"].get(\"0\", 0),\n",
+    "        results[\"solution_state_probabilities\"].get(\"1\", 0),\n",
+    "    ]\n",
+    "    classical_probs = list(results[\"classical_probabilities\"])\n",
+    "\n",
+    "    x = np.arange(2)\n",
+    "    width = 0.35\n",
+    "    ax.bar(x - width / 2, quantum_probs, width, label=\"Quantum\", color=\"coral\", alpha=0.8)\n",
+    "    ax.bar(x + width / 2, classical_probs, width, label=\"Classical\", color=\"steelblue\", alpha=0.8)\n",
+    "    ax.set_xlabel(\"Component\")\n",
+    "    ax.set_ylabel(\"Probability |x_i|²\")\n",
+    "    ax.set_title(f\"b = {label} (F={results['fidelity']:.3f})\")\n",
+    "    ax.set_xticks(x)\n",
+    "    ax.set_xticklabels([\"|0⟩\", \"|1⟩\"])\n",
+    "    ax.legend()\n",
+    "    ax.set_ylim([0, 1.1])\n",
+    "\n",
+    "plt.suptitle(\n",
+    "    \"HHL Solutions for A = [[2,1],[1,2]] with Different Input Vectors\",\n",
+    "    fontsize=14,\n",
+    "    fontweight=\"bold\",\n",
+    ")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8e843473-e2ac-4a9e-a438-ce82300a522a",
+   "metadata": {},
+   "source": [
+    "## Practical Considerations and Limitations\n",
+    "\n",
+    "### When Does HHL Provide a Speedup?\n",
+    "\n",
+    "The HHL algorithm provides an exponential speedup when:\n",
+    "1. The matrix $A$ is **sparse** (few non-zero entries per row)\n",
+    "2. The matrix is **well-conditioned** (small condition number $\\kappa$)\n",
+    "3. Only **summary statistics** of the solution are needed (not the full vector)\n",
+    "4. The state $|b\\rangle$ can be **efficiently prepared**\n",
+    "\n",
+    "### Current Limitations\n",
+    "\n",
+    "- **Qubit count**: For an $N \\times N$ system, the algorithm requires $O(\\log N)$ qubits for the input register plus additional qubits for QPE and ancilla\n",
+    "- **Circuit depth**: The QPE and Hamiltonian simulation steps can require deep circuits\n",
+    "- **Post-selection**: The success probability depends on the condition number, requiring $O(\\kappa)$ repetitions\n",
+    "- **Noise**: Current NISQ devices have limited coherence times and gate fidelities\n",
+    "\n",
+    "### Applications\n",
+    "\n",
+    "Despite these limitations, HHL has been proposed for many applications:\n",
+    "- **Machine Learning**: Linear regression, support vector machines, principal component analysis\n",
+    "- **Computational Finance**: Portfolio optimization, options pricing via PDEs\n",
+    "- **Scientific Computing**: Solving differential equations, finite element methods\n",
+    "- **Quantum Chemistry**: Solving coupled cluster equations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9531bd33-121e-4ec7-9dbf-d79718b97fee",
+   "metadata": {},
+   "source": [
+    "## [Optional] Run on a QPU or Managed Simulator\n",
+    "\n",
+    "The following cells demonstrate how to run the HHL algorithm on an Amazon Braket managed simulator or QPU.\n",
+    "\n",
+    "Note: Running on a QPU will incur costs. Use the [Braket cost tracker](https://docs.aws.amazon.com/braket/latest/developerguide/braket-pricing.html#real-time-cost-tracking) to estimate costs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a037c8a6-6de2-456e-a38d-014259d68759",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:22.108049Z",
+     "iopub.status.busy": "2026-02-26T22:09:22.107809Z",
+     "iopub.status.idle": "2026-02-26T22:09:22.154652Z",
+     "shell.execute_reply": "2026-02-26T22:09:22.153160Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
+    "# from braket.tracking import Tracker\n",
+    "\n",
+    "# tracker = Tracker().start()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "feee56a0-e6d3-41eb-8929-88fa8a311857",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:22.157569Z",
+     "iopub.status.busy": "2026-02-26T22:09:22.157286Z",
+     "iopub.status.idle": "2026-02-26T22:09:22.204121Z",
+     "shell.execute_reply": "2026-02-26T22:09:22.202805Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# from braket.aws import AwsDevice\n",
+    "\n",
+    "# # Define the system\n",
+    "# A_qpu = np.array([[1, 0], [0, 2]], dtype=complex)\n",
+    "# b_qpu = np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex)\n",
+    "\n",
+    "# # Build the circuit\n",
+    "# hhl_circ_qpu = hhl_circuit(A_qpu, b_qpu, num_clock_qubits=2)\n",
+    "\n",
+    "# # Run on managed simulator (uncomment the QPU line to run on a real device)\n",
+    "# # qpu = AwsDevice(\"arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-2\")\n",
+    "# managed_device = AwsDevice(\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\")\n",
+    "\n",
+    "# print(\"Running HHL on managed simulator...\")\n",
+    "# task_qpu = run_hhl(hhl_circ_qpu, managed_device, shots=10000)\n",
+    "# print(\"HHL Run Complete!\")\n",
+    "\n",
+    "# results_qpu = get_hhl_results(\n",
+    "#     task_qpu, A_qpu, b_qpu, num_clock_qubits=2, verbose=True\n",
+    "# )\n",
+    "\n",
+    "# plot_hhl_comparison(results_qpu, \"HHL on Managed Simulator\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b4a7a045-69bb-4f6a-be0c-c5ec56c2d9b9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-26T22:09:22.206771Z",
+     "iopub.status.busy": "2026-02-26T22:09:22.206449Z",
+     "iopub.status.idle": "2026-02-26T22:09:22.253130Z",
+     "shell.execute_reply": "2026-02-26T22:09:22.251899Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# print(\"Task Summary\")\n",
+    "# print(f\"{tracker.quantum_tasks_statistics()} \\n\")\n",
+    "# print(\n",
+    "#     f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "19fa3987-afd7-4665-8652-d1e990b5a421",
+   "metadata": {},
+   "source": [
+    "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "819903ab-f718-46fb-b315-ce39d68ade09",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "[[1] A. W. Harrow, A. Hassidim, S. Lloyd, \"Quantum algorithm for linear systems of equations\", Phys. Rev. Lett. 103, 150502 (2009)](https://arxiv.org/abs/0811.3171)\n",
+    "\n",
+    "[[2] Wikipedia: HHL Algorithm](https://en.wikipedia.org/wiki/HHL_algorithm)\n",
+    "\n",
+    "[[3] S. Barz et al., \"A two-qubit photonic quantum processor and its application to solving systems of linear equations\", Scientific Reports 4, 6115 (2014)](https://arxiv.org/abs/1302.1210)\n",
+    "\n",
+    "[[4] X.-D. Cai et al., \"Experimental Quantum Computing to Solve Systems of Linear Equations\", Phys. Rev. Lett. 110, 230501 (2013)](https://arxiv.org/abs/1302.4310)\n",
+    "\n",
+    "[[5] J. Pan et al., \"Experimental realization of quantum algorithm for solving linear systems of equations\", Phys. Rev. A 89, 022313 (2014)](https://arxiv.org/abs/1302.1946)"
+   ]
+  }
+ ],
+ "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.13.2"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/setup.py b/setup.py
index a2670557..c89aa705 100644
--- a/setup.py
+++ b/setup.py
@@ -34,6 +34,7 @@
         "scipy>=1.5.2",
         # Sympy 1.13 produces different results for Simon's algorithm
         "sympy<1.13",
+        "qiskit-braket-provider",
     ],
     extras_require={
         "test": [
diff --git a/src/braket/experimental/algorithms/hhl/__init__.py b/src/braket/experimental/algorithms/hhl/__init__.py
new file mode 100644
index 00000000..ff2f6bbf
--- /dev/null
+++ b/src/braket/experimental/algorithms/hhl/__init__.py
@@ -0,0 +1,5 @@
+from braket.experimental.algorithms.hhl.hhl import (  # noqa: F401,E501
+    get_hhl_results,
+    hhl_circuit,
+    run_hhl,
+)
diff --git a/src/braket/experimental/algorithms/hhl/hhl.md b/src/braket/experimental/algorithms/hhl/hhl.md
new file mode 100644
index 00000000..ea0ba2c3
--- /dev/null
+++ b/src/braket/experimental/algorithms/hhl/hhl.md
@@ -0,0 +1,7 @@
+The Harrow-Hassidim-Lloyd (HHL) algorithm is a quantum algorithm for solving systems of linear equations of the form Ax = b. Given an N×N Hermitian matrix A and a unit vector b, the algorithm produces a quantum state |x⟩ whose amplitudes encode the solution vector x = A⁻¹b. For sparse, well-conditioned matrices, HHL runs in O(log(N) κ²) time versus O(Nκ) classically, where κ is the condition number of A. However, the overall speedup depends on the efficiency of state preparation and readout, which can be problem-dependent. Applications include machine learning, computational finance, solving differential equations, and quantum chemistry.
+
+<!-- 
+[metadata-name]: HHL Algorithm
+[metadata-tags]: Advanced
+[metadata-url]: https://github.com/amazon-braket/amazon-braket-algorithm-library/blob/main/src/braket/experimental/algorithms/hhl
+-->
diff --git a/src/braket/experimental/algorithms/hhl/hhl.py b/src/braket/experimental/algorithms/hhl/hhl.py
new file mode 100644
index 00000000..f3afb23d
--- /dev/null
+++ b/src/braket/experimental/algorithms/hhl/hhl.py
@@ -0,0 +1,558 @@
+"""Harrow-Hassidim-Lloyd (HHL) Algorithm for Solving Linear Systems of Equations.
+
+The HHL algorithm is a quantum algorithm for solving systems of linear equations
+of the form Ax = b. Given an N x N Hermitian matrix A and a unit vector b, the
+algorithm produces a quantum state |x> proportional to A^{-1}|b>.
+
+For certain classes of problems (sparse, well-conditioned matrices), and when only
+summary statistics of the solution are needed (e.g., <x|M|x> for some operator M),
+HHL can offer a speedup over classical methods. However, the overall advantage
+depends on the efficiency of state preparation and readout.
+
+This implementation provides a simplified version of HHL suitable for small systems
+(2x2 matrices), illustrating the core concepts:
+1. State preparation: encode |b> into a quantum state
+2. Quantum Phase Estimation (QPE): decompose |b> in the eigenbasis of A
+3. Controlled rotation: apply the eigenvalue inversion C/lambda
+4. Inverse QPE: uncompute the eigenvalue register
+5. Measurement: post-select on the ancilla qubit
+
+References:
+    [1] A. W. Harrow, A. Hassidim, S. Lloyd, "Quantum algorithm for linear systems
+        of equations", Phys. Rev. Lett. 103, 150502 (2009). arXiv:0811.3171
+    [2] Wikipedia: https://en.wikipedia.org/wiki/HHL_algorithm
+"""
+
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.library import UnitaryGate
+from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
+from qiskit_braket_provider.providers.adapter import to_braket
+
+from braket.circuits import Circuit, circuit
+from braket.circuits.qubit_set import QubitSetInput
+from braket.devices import Device
+from braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform import (
+    iqft,
+    qft,
+)
+from braket.tasks import QuantumTask
+
+
+# Public API
+@circuit.subroutine(register=True)
+def hhl_circuit(
+    matrix: np.ndarray,
+    b_vector: np.ndarray,
+    num_clock_qubits: int = 2,
+    scaling_factor: Optional[float] = None,
+) -> Circuit:
+    """Construct the full HHL circuit for solving Ax = b.
+
+    The circuit uses:
+    - 1 input qubit for encoding |b>
+    - num_clock_qubits clock qubits for QPE
+    - 1 ancilla qubit for eigenvalue inversion (post-selection)
+
+    Qubit layout:
+    - Clock qubits: 0 to num_clock_qubits - 1
+    - Input qubit: num_clock_qubits
+    - Ancilla qubit: num_clock_qubits + 1
+
+    Args:
+        matrix (np.ndarray): A 2x2 Hermitian matrix A.
+        b_vector (np.ndarray): A normalized 2-element vector b.
+        num_clock_qubits (int): Number of clock qubits for QPE (default: 2).
+        scaling_factor (Optional[float]): Scaling factor for Hamiltonian simulation.
+            If None, automatically computed from the eigenvalues.
+
+    Returns:
+        Circuit: The complete HHL circuit.
+
+    Raises:
+        ValueError: If matrix is not 2x2 Hermitian or b_vector is invalid.
+    """
+    _validate_hermitian_2x2(matrix)
+
+    # Normalize b_vector
+    b_norm = np.linalg.norm(b_vector)
+    if b_norm < 1e-10:
+        raise ValueError("b_vector must be non-zero")
+    b_normalized = b_vector / b_norm
+
+    # Compute eigenvalues for scaling
+    eigenvalues, _ = np.linalg.eigh(matrix)
+
+    # Determine scaling factor if not provided
+    if scaling_factor is None:
+        # Map the full range of eigenvalues into the QPE register
+        max_eigenval = max(abs(ev) for ev in eigenvalues)
+        num_states = 2**num_clock_qubits
+        # Scale so that eigenvalues map to distinct, well-separated QPE states
+        # using the eigenvalue range to ensure all eigenvalues are representable
+        scaling_factor = 2 * np.pi * (num_states - 1) / (max_eigenval * num_states)
+
+    # Define qubit registers
+    clock_qubits = list(range(num_clock_qubits))
+    input_qubit = num_clock_qubits
+    ancilla_qubit = num_clock_qubits + 1
+
+    # Build the circuit
+    circ = Circuit()
+
+    # Step 1: State preparation - encode |b> on the input qubit
+    circ = _prepare_state_b(circ, input_qubit, b_normalized)
+
+    # Step 2: Quantum Phase Estimation
+    qpe_circ = _qpe_for_hhl(clock_qubits, input_qubit, matrix, scaling_factor)
+    circ.add(qpe_circ)
+
+    # Step 3: Controlled rotation (eigenvalue inversion)
+    rotation_circ = _controlled_rotation(
+        clock_qubits, ancilla_qubit, eigenvalues, num_clock_qubits, scaling_factor
+    )
+    circ.add(rotation_circ)
+
+    # Step 4: Inverse QPE (uncompute clock register)
+    inv_qpe_circ = _inverse_qpe_for_hhl(clock_qubits, input_qubit, matrix, scaling_factor)
+    circ.add(inv_qpe_circ)
+
+    return circ
+
+
+def run_hhl(
+    circuit: Circuit,
+    device: Device,
+    shots: int = 1000,
+) -> QuantumTask:
+    """Run the HHL circuit on the specified device.
+
+    Args:
+        circuit (Circuit): The HHL circuit to run.
+        device (Device): Braket device backend.
+        shots (int): Number of measurement shots (default: 1000).
+
+    Returns:
+        QuantumTask: Task from running HHL.
+    """
+    task = device.run(circuit, shots=shots)
+    return task
+
+
+def get_hhl_results(
+    task: QuantumTask,
+    matrix: np.ndarray,
+    b_vector: np.ndarray,
+    num_clock_qubits: int = 2,
+    verbose: bool = False,
+) -> Dict[str, Any]:
+    """Post-process results from an HHL run.
+
+    Extracts the solution state by post-selecting on the ancilla qubit
+    measuring |1>. The solution |x> is proportional to A^{-1}|b>.
+
+    Args:
+        task (QuantumTask): The task containing HHL results.
+        matrix (np.ndarray): The original 2x2 matrix A.
+        b_vector (np.ndarray): The original vector b.
+        num_clock_qubits (int): Number of clock qubits used (default: 2).
+        verbose (bool): If True, prints detailed results (default: False).
+
+    Returns:
+        Dict[str, Any]: Dictionary containing:
+            - measurement_counts: Raw measurement counts
+            - post_selected_counts: Counts post-selected on ancilla=1
+            - solution_state_probabilities: Probabilities of solution components
+            - classical_solution: The exact classical solution for comparison
+            - fidelity: Fidelity between quantum and classical solutions
+            - success_probability: Probability of ancilla measuring |1>
+    """
+    result = task.result()
+    measurement_counts = result.measurement_counts
+
+    # Compute classical solution for comparison
+    b_norm = np.linalg.norm(b_vector)
+    b_normalized = b_vector / b_norm
+    classical_solution = np.linalg.solve(matrix, b_normalized)
+    classical_solution_normalized = classical_solution / np.linalg.norm(classical_solution)
+
+    # Post-select: keep only measurements where ancilla (last qubit) = 1
+    # and clock qubits are all 0 (indicating successful uncomputation)
+    post_selected_counts = {}
+    total_shots = sum(measurement_counts.values())
+    success_shots = 0
+
+    for bitstring, count in measurement_counts.items():
+        # Bit ordering: clock_qubits | input_qubit | ancilla_qubit
+        ancilla_bit = bitstring[-1]  # Last qubit is ancilla
+        clock_bits = bitstring[:num_clock_qubits]
+
+        if ancilla_bit == "1" and all(b == "0" for b in clock_bits):
+            input_bit = bitstring[num_clock_qubits]
+            if input_bit in post_selected_counts:
+                post_selected_counts[input_bit] += count
+            else:
+                post_selected_counts[input_bit] = count
+            success_shots += count
+
+    # Compute solution state probabilities from post-selected counts
+    solution_state_probs = {}
+    if success_shots > 0:
+        for state, count in post_selected_counts.items():
+            solution_state_probs[state] = count / success_shots
+    else:
+        solution_state_probs = {"0": 0.0, "1": 0.0}
+
+    success_probability = success_shots / total_shots if total_shots > 0 else 0.0
+
+    # Compute fidelity between quantum result and classical solution
+    quantum_probs = np.array(
+        [
+            solution_state_probs.get("0", 0.0),
+            solution_state_probs.get("1", 0.0),
+        ]
+    )
+    classical_probs = np.abs(classical_solution_normalized) ** 2
+
+    # Fidelity F = (sum sqrt(p_i * q_i))^2
+    fidelity = (np.sum(np.sqrt(quantum_probs * classical_probs))) ** 2
+
+    aggregate_results = {
+        "measurement_counts": measurement_counts,
+        "post_selected_counts": post_selected_counts,
+        "solution_state_probabilities": solution_state_probs,
+        "classical_solution": classical_solution,
+        "classical_solution_normalized": classical_solution_normalized,
+        "classical_probabilities": classical_probs,
+        "fidelity": fidelity,
+        "success_probability": success_probability,
+        "total_shots": total_shots,
+        "success_shots": success_shots,
+    }
+
+    if verbose:
+        print(f"Matrix A:\n{matrix}")
+        print(f"\nVector b: {b_vector}")
+        print(f"\nClassical solution x = A^(-1)b: {classical_solution}")
+        print(f"Classical solution (normalized): {classical_solution_normalized}")
+        print(f"Classical probabilities |x_i|^2: {classical_probs}")
+        print(f"\nTotal measurement shots: {total_shots}")
+        print(f"Post-selection success shots: {success_shots}")
+        print(f"Success probability: {success_probability:.4f}")
+        print(f"\nPost-selected counts: {post_selected_counts}")
+        print(f"Quantum solution probabilities: {solution_state_probs}")
+        print(f"\nFidelity with classical solution: {fidelity:.4f}")
+
+    return aggregate_results
+
+
+# Private helpers
+def _validate_hermitian_2x2(matrix: np.ndarray) -> None:
+    """Validate that the input is a 2x2 Hermitian matrix.
+
+    Args:
+        matrix (np.ndarray): The matrix to validate.
+
+    Raises:
+        ValueError: If the matrix is not 2x2 or not Hermitian.
+    """
+    if matrix.shape != (2, 2):
+        raise ValueError(f"Matrix must be 2x2, got shape {matrix.shape}")
+    if not np.allclose(matrix, matrix.conj().T, atol=1e-10):
+        raise ValueError("Matrix must be Hermitian (A = A†)")
+
+
+def _qpe_for_hhl(
+    clock_qubits: QubitSetInput,
+    input_qubit: int,
+    matrix: np.ndarray,
+    scaling_factor: float,
+) -> Circuit:
+    """Quantum Phase Estimation subroutine for HHL.
+
+    Applies the QPE circuit to estimate eigenvalues of the Hermitian matrix A.
+    Uses Hamiltonian simulation via e^{iAt} for a 2x2 system.
+
+    Args:
+        clock_qubits (QubitSetInput): Clock register qubits.
+        input_qubit (int): The input qubit encoding |b>.
+        matrix (np.ndarray): The 2x2 Hermitian matrix A.
+        scaling_factor (float): Time parameter for Hamiltonian simulation.
+
+    Returns:
+        Circuit: QPE circuit.
+    """
+    circ = Circuit()
+    num_clock = len(clock_qubits)
+
+    # Apply Hadamard to clock qubits
+    circ.h(clock_qubits)
+
+    # Apply controlled-U^(2^k) operations
+    # U = e^{iA * scaling_factor / num_states}
+    # For clock qubit k, apply U^(2^k)
+    for k, clock_qubit in enumerate(reversed(clock_qubits)):
+        power = 2**k
+        # Compute U^power = e^{i * A * scaling_factor * power / (2^num_clock)}
+        t = scaling_factor * power / (2**num_clock)
+        unitary = _compute_hamiltonian_simulation(matrix, t)
+
+        # Decompose controlled unitary into 1q/2q gates and add to circuit
+        cu_circ = _decompose_controlled_unitary(unitary, [clock_qubit, input_qubit])
+        circ.add_circuit(cu_circ)
+
+    # Apply inverse QFT to clock register using the library's iqft
+    circ.add(iqft(clock_qubits))
+
+    return circ
+
+
+def _compute_hamiltonian_simulation(matrix: np.ndarray, t: float) -> np.ndarray:
+    """Compute the unitary e^{iAt} for the Hamiltonian simulation.
+
+    For a 2x2 Hermitian matrix, uses eigendecomposition for exact computation.
+
+    Args:
+        matrix (np.ndarray): The Hermitian matrix A.
+        t (float): The time parameter.
+
+    Returns:
+        np.ndarray: The unitary matrix e^{iAt}.
+    """
+    eigenvalues, eigenvectors = np.linalg.eigh(matrix)
+    # e^{iAt} = V * diag(e^{i*lambda_j*t}) * V†
+    phases = np.exp(1j * eigenvalues * t)
+    unitary = eigenvectors @ np.diag(phases) @ eigenvectors.conj().T
+    return unitary
+
+
+def _decompose_controlled_unitary(
+    unitary: np.ndarray,
+    targets: List[int],
+) -> Circuit:
+    """Decompose a controlled-U gate into native 1q/2q gates via Qiskit transpilation.
+
+    Constructs a controlled-U gate from a 2x2 unitary U, then uses
+    Qiskit's transpiler to decompose it into U + CX gates, and converts the
+    result to a Braket circuit mapped onto the specified target qubits.
+
+    Args:
+        unitary (np.ndarray): The 2x2 unitary matrix U.
+        targets (List[int]): Target qubit indices [control, target].
+
+    Returns:
+        Circuit: Braket circuit implementing the controlled-U with native gates.
+    """
+    if unitary.shape != (2, 2):
+        raise ValueError("Only 2x2 unitaries supported for explicit control construction")
+
+    # Build a Qiskit circuit with the UnitaryGate controlled on 1 qubit
+    cu_gate = UnitaryGate(unitary).control(1)
+    qc = QuantumCircuit(2)
+    qc.append(cu_gate, [0, 1])
+
+    # Transpile into 1q/2q basis gates
+    pm = generate_preset_pass_manager(
+        optimization_level=2,
+        basis_gates=["cx", "u", "id", "rz", "sx", "x"],
+    )
+    transpiled = pm.run(qc)
+
+    # If transpilation optimized away all gates, return empty circuit
+    if transpiled.size() == 0:
+        return Circuit()
+
+    # Determine which original Qiskit qubits are actually used in the
+    # transpiled circuit, so we can map them to the correct target qubits.
+    active_qiskit_indices = sorted(
+        {transpiled.qubits.index(q) for instr in transpiled.data for q in instr.qubits}
+    )
+
+    # Convert transpiled Qiskit circuit to Braket circuit
+    braket_circ = to_braket(transpiled)
+
+    # Map each active Qiskit qubit index to the corresponding target qubit.
+    # Qiskit qubit 0 -> targets[0] (control), qubit 1 -> targets[1] (target).
+    # The Braket circuit's qubits are numbered 0..n-1 in the same order
+    # as the active Qiskit qubits.
+    target_mapping = [targets[i] for i in active_qiskit_indices]
+    remapped = Circuit()
+    remapped.add_circuit(braket_circ, target=target_mapping)
+    return remapped
+
+
+def _controlled_rotation(
+    clock_qubits: QubitSetInput,
+    ancilla_qubit: int,
+    eigenvalues: np.ndarray,
+    num_clock_qubits: int,
+    scaling_factor: float,
+) -> Circuit:
+    """Apply controlled rotations to encode C/lambda into the ancilla qubit.
+
+    For each eigenvalue lambda_j, performs a controlled-Ry rotation on the
+    ancilla qubit conditioned on the clock register containing |lambda_j>.
+    After rotation, the ancilla is in state:
+        sqrt(1 - C^2/lambda_j^2)|0> + C/lambda_j|1>
+
+    Measuring |1> on the ancilla post-selects the desired solution.
+
+    Args:
+        clock_qubits (QubitSetInput): Clock register qubits.
+        ancilla_qubit (int): The ancilla qubit for post-selection.
+        eigenvalues (np.ndarray): Eigenvalues of matrix A.
+        num_clock_qubits (int): Number of clock qubits.
+        scaling_factor (float): Scaling factor for eigenvalue encoding.
+
+    Returns:
+        Circuit: Circuit with controlled rotations.
+    """
+    circ = Circuit()
+    num_states = 2**num_clock_qubits
+
+    # Compute the constant C (normalization)
+    abs_eigenvalues = np.abs(eigenvalues[np.abs(eigenvalues) > 1e-10])
+    if len(abs_eigenvalues) == 0:
+        return circ
+    c_value = np.min(abs_eigenvalues)
+
+    # For each possible clock register state, apply a controlled rotation
+    for clock_state in range(1, num_states):
+        # Reconstruct the eigenvalue from the clock state
+        reconstructed_eigenval = (2 * np.pi * clock_state) / (scaling_factor * num_states)
+
+        # Compute rotation angle
+        ratio = c_value / abs(reconstructed_eigenval)
+        ratio = min(ratio, 1.0)
+        theta = 2 * np.arcsin(ratio)
+
+        if abs(theta) < 1e-12:
+            continue
+
+        # Convert clock_state to binary to determine which clock qubits are |0> vs |1>
+        binary_rep = format(clock_state, f"0{num_clock_qubits}b")
+
+        # Apply X gates to select the correct clock state
+        for i, bit in enumerate(binary_rep):
+            if bit == "0":
+                circ.x(clock_qubits[i])
+
+        # Apply multi-controlled Ry using Braket's built-in control mechanism
+        _add_multi_controlled_ry(circ, list(clock_qubits), ancilla_qubit, theta)
+
+        # Undo X gates
+        for i, bit in enumerate(binary_rep):
+            if bit == "0":
+                circ.x(clock_qubits[i])
+
+    return circ
+
+
+def _add_multi_controlled_ry(circ: Circuit, controls: list, target: int, theta: float) -> None:
+    """Add a multi-controlled Ry gate to the circuit.
+
+    Uses Braket's built-in control mechanism for the Ry gate.
+
+    Args:
+        circ (Circuit): The circuit.
+        controls (list): Control qubits.
+        target (int): Target qubit.
+        theta (float): Rotation angle.
+    """
+    if len(controls) == 1:
+        # Use Braket's built-in controlled Ry
+        circ.ry(target, theta, control=controls[0])
+    else:
+        # For multiple controls, decompose recursively:
+        # C^n-Ry(theta) = C^(n-1)-Ry(theta/2) . CNOT . C^(n-1)-Ry(-theta/2) . CNOT . ...
+        _add_multi_controlled_ry(circ, controls[1:], target, theta / 2)
+        circ.cnot(controls[0], controls[-1])
+        _add_multi_controlled_ry(circ, controls[1:], target, -theta / 2)
+        circ.cnot(controls[0], controls[-1])
+        _add_multi_controlled_ry(circ, controls[:-1], target, theta / 2)
+
+
+def _inverse_qpe_for_hhl(
+    clock_qubits: QubitSetInput,
+    input_qubit: int,
+    matrix: np.ndarray,
+    scaling_factor: float,
+) -> Circuit:
+    """Inverse QPE subroutine to uncompute the clock register.
+
+    Args:
+        clock_qubits (QubitSetInput): Clock register qubits.
+        input_qubit (int): The input qubit.
+        matrix (np.ndarray): The 2x2 Hermitian matrix A.
+        scaling_factor (float): Time parameter for Hamiltonian simulation.
+
+    Returns:
+        Circuit: Inverse QPE circuit.
+    """
+    circ = Circuit()
+    num_clock = len(clock_qubits)
+
+    # Apply forward QFT to clock register (inverse of inverse QFT)
+    circ.add(qft(clock_qubits))
+
+    # Apply inverse controlled-U^(2^k) operations (in reverse order)
+    for k, clock_qubit in enumerate(reversed(clock_qubits)):
+        power = 2**k
+        t = scaling_factor * power / (2**num_clock)
+        # Inverse unitary: (e^{iAt})† = e^{-iAt}
+        unitary_inv = _compute_hamiltonian_simulation(matrix, -t)
+
+        # Decompose inverse controlled unitary into 1q/2q gates
+        cu_inv_circ = _decompose_controlled_unitary(unitary_inv, [clock_qubit, input_qubit])
+        circ.add_circuit(cu_inv_circ)
+
+    # Apply Hadamard to clock qubits
+    circ.h(clock_qubits)
+
+    return circ
+
+
+def _prepare_state_b(circ: Circuit, input_qubit: int, b_vector: np.ndarray) -> Circuit:
+    """Prepare the quantum state |b> on the input qubit.
+
+    For a 2-element vector b = [b0, b1], prepares the state:
+        |b> = b0|0> + b1|1>
+
+    The vector must be normalized (|b0|^2 + |b1|^2 = 1).
+
+    Args:
+        circ (Circuit): The circuit to add state preparation to.
+        input_qubit (int): The qubit to prepare the state on.
+        b_vector (np.ndarray): The normalized 2-element vector b.
+
+    Returns:
+        Circuit: Circuit with state preparation.
+
+    Raises:
+        ValueError: If b_vector is not a normalized 2-element vector.
+    """
+    if len(b_vector) != 2:
+        raise ValueError(f"b_vector must have 2 elements, got {len(b_vector)}")
+
+    norm = np.linalg.norm(b_vector)
+    if not np.isclose(norm, 1.0, atol=1e-10):
+        raise ValueError(f"b_vector must be normalized, got norm={norm}")
+
+    # Compute the rotation angle to prepare |b> = cos(theta/2)|0> + sin(theta/2)|1>
+    theta = 2 * np.arccos(np.clip(np.real(b_vector[0]), -1, 1))
+
+    # Handle the phase if b_vector has complex components
+    if np.isreal(b_vector).all():
+        if np.real(b_vector[1]) < 0:
+            theta = -theta
+        circ.ry(input_qubit, theta)
+    else:
+        # General state preparation for complex amplitudes
+        # |b> = cos(theta/2)|0> + e^{i*phi}*sin(theta/2)|1>
+        phi = np.angle(b_vector[1]) - np.angle(b_vector[0])
+        circ.ry(input_qubit, theta)
+        circ.rz(input_qubit, phi)
+
+    return circ
diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test/unit_tests/__init__.py b/test/unit_tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test/unit_tests/braket/__init__.py b/test/unit_tests/braket/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test/unit_tests/braket/experimental/__init__.py b/test/unit_tests/braket/experimental/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test/unit_tests/braket/experimental/algorithms/__init__.py b/test/unit_tests/braket/experimental/algorithms/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/__init__.py b/test/unit_tests/braket/experimental/algorithms/hhl/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py
new file mode 100644
index 00000000..2d3590f4
--- /dev/null
+++ b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py
@@ -0,0 +1,397 @@
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+from braket.circuits import Circuit
+from braket.devices import LocalSimulator
+from braket.experimental.algorithms.hhl import hhl as hhl_module
+
+
+# Test with a simple diagonal 2x2 matrix
+def test_hhl_diagonal_matrix():
+    """Test HHL with a diagonal Hermitian matrix."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+
+    assert circ is not None
+    assert circ.qubit_count == 4  # 2 clock + 1 input + 1 ancilla
+
+
+# Test with a symmetric 2x2 matrix
+def test_hhl_symmetric_matrix():
+    """Test HHL with a symmetric Hermitian matrix."""
+    matrix = np.array([[2, 1], [1, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+
+    assert circ is not None
+    assert circ.qubit_count == 4
+
+
+# Test validation: non-Hermitian matrix should raise error
+def test_hhl_non_hermitian_raises():
+    """Test that a non-Hermitian matrix raises ValueError."""
+    matrix = np.array([[1, 2], [3, 4]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    with pytest.raises(ValueError, match="Hermitian"):
+        hhl_module.hhl_circuit(matrix, b_vector)
+
+
+# Test validation: wrong-sized matrix should raise error
+def test_hhl_wrong_size_matrix_raises():
+    """Test that a non-2x2 matrix raises ValueError."""
+    matrix = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=complex)
+    b_vector = np.array([1, 0, 0], dtype=complex)
+
+    with pytest.raises(ValueError, match="2x2"):
+        hhl_module.hhl_circuit(matrix, b_vector)
+
+
+# Test validation: unnormalized b_vector should raise error
+def test_hhl_zero_b_vector_raises():
+    """Test that a zero b_vector raises ValueError."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([0, 0], dtype=complex)
+
+    with pytest.raises(ValueError, match="non-zero"):
+        hhl_module.hhl_circuit(matrix, b_vector)
+
+
+# Test state preparation
+def test_state_preparation_basic():
+    """Test that state preparation works for basic vectors."""
+    from braket.circuits import Circuit
+
+    circ = Circuit()
+    b_vector = np.array([1, 0], dtype=float)
+    circ = hhl_module._prepare_state_b(circ, 0, b_vector)
+    assert circ is not None
+
+
+# Test state preparation with superposition
+def test_state_preparation_superposition():
+    """Test state preparation for a superposition vector."""
+    from braket.circuits import Circuit
+
+    circ = Circuit()
+    b_vector = np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=float)
+    circ = hhl_module._prepare_state_b(circ, 0, b_vector)
+    assert circ is not None
+
+
+# Test Hamiltonian simulation
+def test_hamiltonian_simulation():
+    """Test that the Hamiltonian simulation produces a unitary matrix."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    t = 1.0
+    unitary = hhl_module._compute_hamiltonian_simulation(matrix, t)
+
+    # Check unitarity: U @ U† = I
+    identity = unitary @ unitary.conj().T
+    assert np.allclose(identity, np.eye(2), atol=1e-10)
+
+
+# Test Hamiltonian simulation at t=0 gives identity
+def test_hamiltonian_simulation_t0():
+    """Test that e^{i*A*0} = I."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    unitary = hhl_module._compute_hamiltonian_simulation(matrix, 0)
+    assert np.allclose(unitary, np.eye(2), atol=1e-10)
+
+
+# Test eigendecomposition
+def test_eigendecomposition():
+    """Test eigendecomposition of a known matrix."""
+    matrix = np.array([[2, 1], [1, 2]], dtype=complex)
+    eigenvalues, eigenvectors = np.linalg.eigh(matrix)
+
+    # Known eigenvalues for [[2,1],[1,2]] are 1 and 3
+    assert np.allclose(sorted(eigenvalues), [1, 3], atol=1e-10)
+
+
+# Test HHL circuit with identity matrix (trivial case)
+def test_hhl_identity_matrix():
+    """Test HHL with identity matrix: solution should be b itself."""
+    matrix = np.array([[1, 0], [0, 1]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+
+    assert circ is not None
+
+
+# Test run_hhl function
+def test_run_hhl():
+    """Test running HHL on local simulator."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+    device = LocalSimulator()
+    task = hhl_module.run_hhl(circ, device, shots=100)
+
+    result = task.result()
+    assert result is not None
+    assert result.measurement_counts is not None
+
+
+# Test get_hhl_results function
+def test_get_hhl_results():
+    """Test post-processing of HHL results."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+    device = LocalSimulator()
+    task = hhl_module.run_hhl(circ, device, shots=1000)
+
+    results = hhl_module.get_hhl_results(task, matrix, b_vector, num_clock_qubits=2, verbose=True)
+
+    assert "measurement_counts" in results
+    assert "post_selected_counts" in results
+    assert "solution_state_probabilities" in results
+    assert "classical_solution" in results
+    assert "fidelity" in results
+    assert "success_probability" in results
+
+    # Classical solution for Ax=b with A=diag(1,2), b=[1,0] is x=[1,0]
+    classical_sol = results["classical_solution"]
+    assert np.allclose(classical_sol, [1, 0], atol=1e-10)
+
+
+# Test validation of b_vector length
+def test_hhl_b_vector_wrong_length_raises():
+    """Test that a b_vector with wrong length raises ValueError."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0, 0], dtype=complex)
+
+    with pytest.raises(ValueError):
+        hhl_module.hhl_circuit(matrix, b_vector)
+
+
+# Test with custom scaling factor
+def test_hhl_custom_scaling():
+    """Test HHL with a custom scaling factor."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2, scaling_factor=np.pi)
+    assert circ is not None
+
+
+# Test with a matrix having negative eigenvalues
+def test_hhl_negative_eigenvalues():
+    """Test HHL circuit creation for a matrix with negative eigenvalues."""
+    # This matrix has eigenvalues -1 and 3
+    matrix = np.array([[1, 2], [2, 1]], dtype=complex)
+
+    # For now just test circuit construction
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+    assert circ is not None
+
+
+def test_prepare_state_b_complex_vector():
+    """Test state preparation with complex amplitudes."""
+    circ = Circuit()
+    # Normalized complex vector: [1/sqrt(2), i/sqrt(2)]
+    b_vector = np.array([1 / np.sqrt(2), 1j / np.sqrt(2)], dtype=complex)
+    circ = hhl_module._prepare_state_b(circ, 0, b_vector)
+
+    # Check if Rz gate is applied (indicates complex path taken)
+    assert any(instruction.operator.name == "Rz" for instruction in circ.instructions)
+
+
+def test_prepare_state_b_negative_component():
+    """Test state preparation with negative real component."""
+    circ = Circuit()
+    # Normalized vector with negative component: [0, -1]
+    # This triggers the `if np.real(b_vector[1]) < 0` branch
+    b_vector = np.array([0, -1], dtype=float)
+    circ = hhl_module._prepare_state_b(circ, 0, b_vector)
+
+    # We can check specific rotation angle if needed,
+    # but mainly we care that it runs without error.
+    assert circ is not None
+
+
+def test_prepare_state_b_unnormalized_raises():
+    """Test that unnormalized b_vector raises ValueError."""
+    circ = Circuit()
+    b_vector = np.array([1, 1], dtype=float)  # Norm is sqrt(2)
+
+    with pytest.raises(ValueError, match="normalized"):
+        hhl_module._prepare_state_b(circ, 0, b_vector)
+
+
+def test_hhl_1_clock_qubit():
+    """Test HHL with 1 clock qubit."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=1)
+
+    # Check controlled rotation structure usage
+    # With 1 clock qubit, it uses _add_controlled_ry
+    # We can inspect the circuit instruction count or similar
+    assert circ is not None
+    # 1 clock + 1 input + 1 ancilla = 3 qubits
+    assert circ.qubit_count == 3
+
+
+def test_hhl_3_clock_qubits():
+    """Test HHL with 3 clock qubits (triggering multi-controlled logic)."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=3)
+
+    # With 3 clock qubits, it uses _add_multi_controlled_ry
+    assert circ is not None
+    # 3 clock + 1 input + 1 ancilla = 5 qubits
+    assert circ.qubit_count == 5
+
+
+def test_get_hhl_results_no_success():
+    """Test get_hhl_results when no shots succeed (no post-selection)."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    # Mock task and result
+    mock_task = MagicMock()
+    mock_result = MagicMock()
+    # All measurements have ancilla=0 (failure)
+    # Format: clock(2) | input(1) | ancilla(1)
+    # e.g., "00" + "0" + "0"
+    mock_result.measurement_counts = {"0000": 100}
+    mock_task.result.return_value = mock_result
+
+    results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2)
+
+    assert results["success_shots"] == 0
+    assert results["success_probability"] == 0.0
+    # Should handle empty dict locally
+    assert results["solution_state_probabilities"] == {"0": 0.0, "1": 0.0}
+
+
+def test_get_hhl_results_multiple_post_selection():
+    """Test get_hhl_results aggregating counts correctly."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    # Mock task and result
+    mock_task = MagicMock()
+    mock_result = MagicMock()
+    # Success cases: ancilla=1, clock=00
+    # "00" + "0" + "1" -> input 0
+    # "00" + "1" + "1" -> input 1
+    mock_result.measurement_counts = {
+        "0001": 30,  # input 0, success
+        "0011": 20,  # input 1, success
+        "1100": 50,  # fail
+    }
+    mock_task.result.return_value = mock_result
+
+    results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2)
+
+    assert results["success_shots"] == 50
+    assert results["post_selected_counts"]["0"] == 30
+    assert results["post_selected_counts"]["1"] == 20
+    assert results["solution_state_probabilities"]["0"] == 0.6
+    assert results["solution_state_probabilities"]["1"] == 0.4
+
+
+def test_post_selected_counts_accumulation():
+    """Test accumulation of post-selected counts for same input bit."""
+    matrix = np.array([[1, 0], [0, 2]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+    num_clock = 2
+
+    mock_task = MagicMock()
+    mock_result = MagicMock()
+    # To hit line `post_selected_counts[input_bit] += count`,
+    # we need multiple bitstrings mapping to same input_bit.
+    # Standard format: clock(2) | input(1) | ancilla(1)
+    # If we have extra "hidden" bits at the end, get_hhl_results relies on indices.
+    # bitstring is opaque.
+    # Ancilla is bitstring[-1].
+    # Clock is bitstring[:num_clock].
+    # Input is bitstring[num_clock].
+
+    # Let's say we have bitstrings "0001A" and "0001B" where both pass.
+    # This requires string length > 4.
+    mock_result.measurement_counts = {
+        "00010": 10,  # "00" clock, input "0", ancilla "0" (fail)
+        "00011": 20,  # "00" clock, input "0", ancilla "1" (success)
+        # We need another string that is "00" + "0" + ... + "1"
+        # Since logic is by index, we can construct arbitrary string.
+        # "00" (clock) + "0" (input) + "X" + "1" (ancilla)
+        # Length 5. clock=0:2, input=2, ancilla=-1.
+        "000X1": 30,  # "00" clock, input "0", ancilla "1"
+    }
+    mock_task.result.return_value = mock_result
+
+    results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=num_clock)
+
+    # Both "00011" and "000X1" map to input "0".
+    # Total count for "0" should be 20 + 30 = 50.
+    assert results["success_shots"] == 50
+    assert results["post_selected_counts"]["0"] == 50
+
+
+def test_controlled_rotation_zeros():
+    """Test controlled rotation with zero eigenvalues."""
+    # If eigenvalues are all "zero" (filtered by 1e-10)
+    eigenvalues = np.array([0.0, 1e-11], dtype=float)
+
+    # Should return empty circuit immediately (line 308)
+    res_circ = hhl_module._controlled_rotation([0, 1], 2, eigenvalues, 2, 1.0)
+
+    assert len(res_circ.instructions) == 0
+
+
+def test_add_multi_controlled_ry_base_case():
+    """Test _add_multi_controlled_ry with 1 control to hit base case."""
+    circ = Circuit()
+    controls = [0]
+    target = 1
+    theta = np.pi
+
+    # Directly call the internal function
+    hhl_module._add_multi_controlled_ry(circ, controls, target, theta)
+
+    # Should produce instructions (uses built-in controlled Ry)
+    assert len(circ.instructions) > 0
+
+
+def test_hhl_small_ratio_skip():
+    """Test skippng of small rotation angles (ratio < 1e-12)."""
+    # Matrix with huge condition number: min=1e-8, max=1e8 -> ratio ~ 1e-16
+    # Both eigenvalues > 1e-10 so c_value is valid.
+    matrix = np.array([[1e-8, 0], [0, 1e8]], dtype=complex)
+    b_vector = np.array([1, 0], dtype=complex)
+
+    # This should trigger the continue statement in _controlled_rotation
+    # for the max eigenvalue component (reconstructed ~ 1e8, c ~ 1e-8)
+    circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2)
+    assert circ is not None
+
+
+def test_decompose_controlled_unitary_wrong_shape():
+    """Test that a non-2x2 unitary raises ValueError in decompose function."""
+    unitary = np.eye(4, dtype=complex)
+    with pytest.raises(ValueError, match="Only 2x2 unitaries"):
+        hhl_module._decompose_controlled_unitary(unitary, [0, 1])
+
+
+def test_decompose_controlled_unitary_empty():
+    """Test decompose_controlled_unitary with an identity unitary (results in 0 gates)."""
+    unitary = np.eye(2, dtype=complex)
+    circ = hhl_module._decompose_controlled_unitary(unitary, [0, 1])
+    assert len(circ.instructions) == 0