diff --git a/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.ipynb b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.ipynb
new file mode 100644
index 000000000..b1b256fab
--- /dev/null
+++ b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.ipynb
@@ -0,0 +1,512 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7a2b8b80",
+   "metadata": {},
+   "source": [
+    "This notebook implements the algorithm discussed in this paper: https://arxiv.org/pdf/2002.08953,\n",
+    "Predicting Many Properties of a Quantum System from Very Few Measurements, by Huang, et al. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7a4eb83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import classiq\n",
+    "classiq.authenticate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "2654850b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from classiq import *\n",
+    "import numpy as np\n",
+    "import random\n",
+    "from classiq.execution import ExecutionSession, ExecutionPreferences, ClassiqBackendPreferences\n",
+    "from classiq.execution import ClassiqSimulatorBackendNames\n",
+    "from typing import List\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "25f6b621",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(555) # Set random seed for unitary selection.\n",
+    "# Global Variables: must be initialized globally because they cannot be passed into main.\n",
+    "ids = [] # \n",
+    "num_qubits = 2\n",
+    "num_snapshots = 100\n",
+    "unitary_ensemble = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "8e926be8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@qfunc(generative=True)\n",
+    "def unitary_application(state: QArray) -> None:\n",
+    "    \"\"\"\n",
+    "    Applies randomly selected unitaries from a unitary ensemble. 1 per qubit. Updates ids with the identifiers\n",
+    "    of the randomly selected unitaries.\n",
+    "\n",
+    "    Args: \n",
+    "        state (QArray): state prepared by the prep_state function, on which the classical shadow will be calculated.\n",
+    "    Returns:\n",
+    "        None.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # For the purposes of this example, we consider the application of a random unitary to be a measurement in a random basis.\n",
+    "    # Instead of applying unitaries, we wish to measure in either the X, Y, or Z bases.\n",
+    "    basis_ids = list(np.random.randint(3, size=num_qubits))\n",
+    "    ids.append(basis_ids)\n",
+    "\n",
+    "    for i in range(num_qubits):\n",
+    "        #ids of 0, 1, 2 correspond to measurements in the X, Y, and Z basis respectively\n",
+    "        if basis_ids[i] == 0: # H is the change-of-basis matrix from X to Z\n",
+    "            H(state[i])\n",
+    "        if basis_ids[i] == 1: # HS^dagger is the change-of-basis matrix from Y to Z\n",
+    "            SDG(state[i])\n",
+    "            H(state[i])\n",
+    "        # A measurement in the computational basis is a measurement in the Z basis. No unitary application needed.\n",
+    "\n",
+    "    # If using a conventional unitary ensemble, uncomment the following code, and disable the code above.\n",
+    "    # num_unitaries = len(unitary_ensemble)\n",
+    "    # unitary_ids = list(np.random.randint(num_unitaries, size=num_qubits))\n",
+    "    # for i in range(num_qubits):\n",
+    "    #     unitary_ensemble[unitary_ids[i]](state[i])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "e6d15061",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@qfunc\n",
+    "def prep_state(qarr: QArray) -> None:\n",
+    "    \"\"\"\n",
+    "    Prepares the desired state. The classical shadow will be calculated on this state.\n",
+    "\n",
+    "    Args:\n",
+    "        qarr (QArray): Zero initialized array of qubit(s).\n",
+    "\n",
+    "    Returns:\n",
+    "        None.\n",
+    "    \"\"\"\n",
+    "    # For the purposes of this example, this function will prepare the Phi^+ bell state.\n",
+    "    H(qarr[0])\n",
+    "    CX(qarr[0], qarr[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "8d0df5c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@qfunc(generative=True)\n",
+    "def main(qarr: Output[QArray]) -> None:\n",
+    "    \"\"\"\n",
+    "    Prepares the desired state and applies the randomly selected unitaries once.\n",
+    "\n",
+    "    Args:\n",
+    "        None.\n",
+    "\n",
+    "    Returns:\n",
+    "        None.\n",
+    "    \"\"\"\n",
+    "    allocate(num_qubits, qarr)\n",
+    "    prep_state(qarr)\n",
+    "    unitary_application(qarr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "40f1523e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calculate_shadow(num_snapshots):\n",
+    "    \"\"\"\n",
+    "    Computes a shadow of size num_snapshots by performing num_snapshots measurements. \n",
+    "\n",
+    "    Args:\n",
+    "        num_snapshots (int): size of shadow, also the number of measurements.\n",
+    "\n",
+    "    Returns:\n",
+    "        snapshots (List[List[int]]): List of measurement results (0 or 1) for each circuit of length num_snapshots.\n",
+    "          Inner lists are num_qubits long.\n",
+    "    \"\"\"\n",
+    "    snapshots=[]\n",
+    "    for i in range(num_snapshots):\n",
+    "        execution_preferences = ExecutionPreferences(\n",
+    "            num_shots=1,\n",
+    "            backend_preferences=ClassiqBackendPreferences(\n",
+    "                backend_name=ClassiqSimulatorBackendNames.SIMULATOR # Set this to best suit your needs.\n",
+    "            ),\n",
+    "            random_seed=np.random.randint(1e6)\n",
+    "        )\n",
+    "        qmod = create_model(main)\n",
+    "        qmod = set_execution_preferences(qmod, execution_preferences)\n",
+    "        qprog = synthesize(qmod)\n",
+    "        job = execute(qprog)\n",
+    "        counts = job.get_sample_result().parsed_counts\n",
+    "        snapshot = list(counts[0].state['qarr'])\n",
+    "        snapshots.append(snapshot) \n",
+    "    return snapshots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "ffb2270f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "snapshots: [[0, 1], [1, 1], [1, 0], [1, 0], [1, 0], [1, 0], [0, 1], [0, 1], [0, 0], [1, 0], [0, 0], [0, 1], [0, 0], [0, 0], [0, 0], [1, 1], [1, 1], [0, 1], [1, 1], [0, 1], [0, 1], [0, 0], [0, 1], [1, 0], [1, 0], [1, 1], [0, 1], [0, 0], [1, 1], [0, 1], [1, 1], [1, 0], [0, 1], [1, 1], [1, 0], [0, 0], [1, 0], [0, 0], [0, 1], [0, 0], [1, 1], [1, 1], [0, 0], [0, 0], [1, 0], [1, 1], [0, 0], [1, 1], [0, 0], [0, 1], [1, 0], [1, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 1], [0, 1], [0, 0], [1, 0], [0, 0], [0, 0], [0, 1], [0, 1], [0, 0], [1, 0], [0, 1], [1, 1], [0, 0], [0, 1], [0, 1], [0, 1], [1, 1], [1, 0], [1, 1], [0, 0], [0, 1], [1, 1], [1, 0], [0, 0], [0, 0], [0, 1], [0, 1], [1, 1], [1, 0], [0, 0], [1, 0], [0, 0], [1, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1], [0, 0], [1, 1], [1, 1], [1, 1], [0, 0]]\n",
+      "ids: [[2, 1], [0, 1], [2, 1], [0, 1], [0, 2], [1, 2], [0, 2], [0, 1], [2, 2], [0, 1], [0, 0], [1, 0], [0, 1], [0, 0], [1, 0], [0, 0], [0, 0], [1, 0], [0, 0], [0, 1], [2, 1], [0, 0], [2, 1], [1, 1], [2, 0], [2, 0], [1, 2], [1, 0], [1, 2], [0, 2], [1, 2], [1, 2], [1, 0], [0, 0], [1, 1], [2, 2], [0, 2], [0, 2], [1, 1], [2, 2], [0, 1], [2, 1], [0, 0], [0, 1], [0, 2], [1, 2], [1, 0], [0, 0], [1, 2], [2, 0], [1, 0], [0, 1], [0, 0], [0, 1], [1, 2], [2, 0], [0, 2], [1, 2], [1, 2], [0, 2], [2, 1], [0, 0], [2, 0], [0, 1], [1, 2], [0, 0], [2, 1], [1, 0], [0, 2], [0, 1], [1, 1], [1, 0], [2, 1], [2, 2], [0, 2], [0, 0], [1, 0], [1, 2], [2, 2], [1, 1], [0, 0], [2, 0], [1, 1], [2, 1], [0, 2], [2, 0], [2, 0], [2, 1], [0, 1], [2, 1], [1, 1], [2, 2], [1, 2], [0, 2], [1, 2], [0, 1], [0, 2], [2, 2], [2, 0], [0, 2]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "snapshots = calculate_shadow(num_snapshots)\n",
+    "print(f\"snapshots: {snapshots}\")\n",
+    "print(f\"ids: {ids}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "e81274f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def single_snapshot_reconstruction(snapshot, single_ids):\n",
+    "    \"\"\"\n",
+    "    Reconstructs the state density matrix from a single snapshot. Helper for reconstruction().\n",
+    "\n",
+    "    Args:\n",
+    "        snapshot (List[int]): Single element of snapshots.\n",
+    "        single_ids (List[int]): Single element of ids.\n",
+    "\n",
+    "    Returns:\n",
+    "        snapshot_state (NumPy array): Single snapshot density matrix reconstruction.\n",
+    "\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Density matrices of computational basis states\n",
+    "    zero_state = np.array([[1, 0], [0, 0]])\n",
+    "    one_state = np.array([[0, 0], [0, 1]])\n",
+    "\n",
+    "    # local qubit unitaries\n",
+    "    SDG_matrix = np.array([[1, 0], [0, -1j]], dtype=complex) # Matrix of S^dagger gate.\n",
+    "    hadamard = (1/np.sqrt(2))*np.array([[1, 1], [1, -1]]) # Matrix of Hadamard gate.\n",
+    "    identity = np.array([[1, 0], [0, 1]]) # Matrix of identity gate.\n",
+    "\n",
+    "    # Invert the unitaries applied in unitary_application(). \n",
+    "    unitaries = [hadamard, hadamard@SDG_matrix, identity] # Contents of unitaries depend on unitary_ensemble. \n",
+    "\n",
+    "\n",
+    "    snapshot_state = [1]\n",
+    "    for i in range(num_qubits):\n",
+    "        state = zero_state if snapshot[i] == 0 else one_state\n",
+    "        U = unitaries[int(single_ids[i])]\n",
+    "\n",
+    "        # Applying Eq. (S44) from Huang, et al.\n",
+    "        local_state = 3 * (U.conjugate().transpose() @ state @ U) - identity\n",
+    "        snapshot_state = np.kron(snapshot_state, local_state)\n",
+    "\n",
+    "    return snapshot_state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "94f374f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def reconstruction(in_snapshots, in_ids):\n",
+    "    \"\"\"\n",
+    "    Performs a full reconstruction of the quantum state density matrix, where the quantum state is that\n",
+    "    prepared in prep_state().\n",
+    "\n",
+    "    Args:\n",
+    "        in_snapshots (List[List[int]]): List of snapshots. Will most likely be the global `snapshots`.\n",
+    "        in_ids (List[List[int]]): List of unitary identifiers. Will most likely be the global `ids`.\n",
+    "\n",
+    "    Returns:\n",
+    "        shadow_state (NumPy array): Full state density matrix reconstruction.\n",
+    "    \"\"\" \n",
+    "    # Average over snapshots.\n",
+    "    shadow_state = np.zeros((2 ** num_qubits, 2 ** num_qubits), dtype=complex)\n",
+    "    for i in range(num_snapshots):\n",
+    "        result = single_snapshot_reconstruction(in_snapshots[i], in_ids[i])\n",
+    "        shadow_state += result\n",
+    "\n",
+    "    return shadow_state/num_snapshots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "b123c535",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Full state density matrix: \n",
+      " [[ 0.4075+0.j      0.105 +0.1575j  0.075 -0.0225j  0.4725+0.j    ]\n",
+      " [ 0.105 -0.1575j  0.1075+0.j      0.1575+0.09j   -0.015 -0.1125j]\n",
+      " [ 0.075 +0.0225j  0.1575-0.09j    0.0775+0.j     -0.03  -0.1575j]\n",
+      " [ 0.4725-0.j     -0.015 +0.1125j -0.03  +0.1575j  0.4075+0.j    ]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "shadow_state = reconstruction(snapshots, ids)\n",
+    "print(f\"Full state density matrix: \\n {np.round(shadow_state, decimals=6)}\") # Rounding for convenience."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "22740815",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bell_state_density_matrix = np.array([[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]])\n",
+    "\n",
+    "ref_state_density_matrix = bell_state_density_matrix # Set this to whatever your reference state density matrix is. \n",
+    "\n",
+    "def norm(ref_state, estimated_state):\n",
+    "    \"\"\"\n",
+    "    Computes the Frobenius norm of a state, i.e. the distance between two operators.\n",
+    "\n",
+    "    Args:\n",
+    "        state (NumPy arra.y): difference of estimated and reconstructed states.\n",
+    "        ref_state_density_matrix (NumPy array): Density matrix of reference state.\n",
+    "        estimated_state (NumPy array): Density matrix of estimated state.\n",
+    "    \n",
+    "    Returns:\n",
+    "        norm (NumPy complex number): Distance between the states.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    state = ref_state - estimated_state\n",
+    "    return np.sqrt(np.trace(state.conjugate().transpose() @ state))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "id": "7cb88e39",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Comparing to: \n",
+      " [[0.5 0.  0.  0.5]\n",
+      " [0.  0.  0.  0. ]\n",
+      " [0.  0.  0.  0. ]\n",
+      " [0.5 0.  0.  0.5]]\n",
+      "Distance: (0.5129327441292862+0j)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Comparing to: \\n {bell_state_density_matrix}\")\n",
+    "print(f\"Distance: {norm(ref_state_density_matrix, shadow_state)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9bd06c8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def estimate_observable(in_snapshots, in_ids, div): #observable parameter excluded for testing\n",
+    "    \"\"\"\n",
+    "    Estimates the expectation value of an observable with respect the state prepared in prep_state().\n",
+    "    As of now, the observable cannot be passed in. The lists representing it must be manually inputted below.\n",
+    "\n",
+    "    Args:\n",
+    "        in_snapshots (List[List[int]]): List of snapshots. Will most likely be the global `snapshots`.\n",
+    "        in_ids (List[List[int]]): List of unitary identifiers. Will most likely be the global `ids`.\n",
+    "        div (int): number of divisions for median-of-means.\n",
+    "\n",
+    "    Returns:\n",
+    "        expval (float): Esimated expectation value.\n",
+    "    \"\"\"\n",
+    "    means = []\n",
+    "    in_snapshots = np.array(in_snapshots)\n",
+    "    in_snapshots = 1 - 2*in_snapshots #change snapshots from containing tuples with {0, 1} to {1, -1} (respective state eigenvalues)\n",
+    "    in_ids = np.array(in_ids)\n",
+    "    # target obs = [] #paulis in observable\n",
+    "    # target_locs = [] #qubits the above paulis act on\n",
+    "\n",
+    "    #pseudocode to populate the above arrays:\n",
+    "    #if observable acts on a single qubit at a time, determine which, and populate the lists\n",
+    "    #if not, \n",
+    "    #   for each operand in the observable, add it to target_obs. the wire that operand acts on is at the same index\n",
+    "    #   in target_locs\n",
+    "\n",
+    "    #assume that observables can be decoded in that way.\n",
+    "\n",
+    "    #As an example, we will decode np.kron(Z, Z), for which the expected result is 1.0.\n",
+    "\n",
+    "    target_obs = [2, 2] # Z basis has identifier 2.\n",
+    "    target_locs = [0, 1] # Z gate acts on both qubits.\n",
+    "\n",
+    "    # To estimate the expectation value of an observable, we must compute the trace of the final density matrix.\n",
+    "    # Therefore, we are simply computing the trace of Eq. S44. \n",
+    "    # We can take a shortcut: Due to the orthogonality of the Pauli operators,\n",
+    "    # it evaluates to ±3 if the Pauli bases of the observable match the corresponding measurement basis, and evaluates to 0 otherwise.\n",
+    "\n",
+    "\n",
+    "    # Divide in_snapshots and in_ids into div chunks.\n",
+    "    for i in range(0, num_snapshots, num_snapshots//div):\n",
+    "        in_snapshots_div, in_ids_div = (\n",
+    "            in_snapshots[i: i + num_snapshots // div],\n",
+    "            in_ids[i: i + num_snapshots // div],\n",
+    "        )\n",
+    "\n",
+    "        # Select all sets of ids that match type and position of Pauli operators\n",
+    "        indices = np.all(in_ids_div[:, target_locs] == target_obs, axis=1)\n",
+    "\n",
+    "        if sum(indices) > 0:\n",
+    "            # Take the product and sum\n",
+    "            product = np.prod(in_snapshots_div[indices][:, target_locs], axis=1)\n",
+    "            means.append(np.sum(product) / sum(indices))\n",
+    "        else:\n",
+    "            means.append(0)\n",
+    "\n",
+    "\n",
+    "    return np.median(means)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae1a8668",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Estimated expectation value: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Estimated expectation value: {estimate_observable(snapshots, ids, div=8)}\") \n",
+    "#Due to the low number of snapshots, this may vary from run to run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "c589bd33",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def error_bound(error, observables, failure_rate=0.01):\n",
+    "    \"\"\"\n",
+    "    Calculate the shadow bound for the Pauli measurement scheme.\n",
+    "\n",
+    "    Implements Eq. (S13) from Huang, et al.\n",
+    "\n",
+    "    Args:\n",
+    "        error (float): The error on the estimator.\n",
+    "        observables (list) : List of matrices corresponding to the observables we intend to measure.\n",
+    "        failure_rate (float): Rate of failure for the bound to hold.\n",
+    "\n",
+    "    Returns:\n",
+    "        An integer that gives the number of samples required to satisfy the shadow bound and\n",
+    "        the chunk size required attaining the specified failure rate. \n",
+    "    \"\"\"\n",
+    "    M = len(observables)\n",
+    "    K = 2 * np.log(2 * M / failure_rate)\n",
+    "    shadow_norm = (\n",
+    "        lambda op: np.linalg.norm(\n",
+    "            op - np.trace(op) / 2 ** int(np.log2(op.shape[0])), ord=np.inf\n",
+    "        )\n",
+    "        ** 2\n",
+    "    )\n",
+    "    N = 34 * max(shadow_norm(o) for o in observables) / error ** 2\n",
+    "    return int(np.ceil(N * K)), int(K)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "75dddd2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of samples required, number of divisions: (1442, 10)\n"
+     ]
+    }
+   ],
+   "source": [
+    "z_gate = np.array([[1, 0], [0, -1]])\n",
+    "o = np.kron(z_gate, z_gate)\n",
+    "observables = []\n",
+    "observables.append(o)\n",
+    "required_snapshots = error_bound(0.5, observables)\n",
+    "print(f\"Number of samples required, number of divisions: {required_snapshots}\") "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.metadata.json b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.metadata.json
new file mode 100644
index 000000000..f681d9403
--- /dev/null
+++ b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.metadata.json
@@ -0,0 +1,7 @@
+{
+    "friendly_name": "Classical Shadows",
+    "description": "Classical shadows algorithm demonstrated a bell state.",
+    "qmod_type": ["algorithms"],
+    "problem_domain_tags": [],
+    "level": ["basic", "demos"]
+  }
\ No newline at end of file
diff --git a/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.qmod b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.qmod
new file mode 100644
index 000000000..bb63632a0
--- /dev/null
+++ b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.qmod
@@ -0,0 +1,13 @@
+qfunc prep_state(qarr: qbit[]) {
+  H(qarr[0]);
+  CX(qarr[0], qarr[1]);
+}
+
+qfunc unitary_application_expanded___0(state: qbit[2]) {
+}
+
+qfunc main(output qarr: qbit[2]) {
+  allocate(2, qarr);
+  prep_state(qarr);
+  unitary_application_expanded___0(qarr);
+}
diff --git a/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.synthesis_options.json b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.synthesis_options.json
new file mode 100644
index 000000000..1e6269865
--- /dev/null
+++ b/algorithms/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements/Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements.synthesis_options.json
@@ -0,0 +1,46 @@
+{
+  "constraints": {
+    "max_gate_count": {},
+    "optimization_parameter": "no_opt"
+  },
+  "preferences": {
+    "machine_precision": 8,
+    "custom_hardware_settings": {
+      "basis_gates": [
+        "id",
+        "cx",
+        "y",
+        "rz",
+        "s",
+        "u",
+        "h",
+        "cy",
+        "sxdg",
+        "u2",
+        "z",
+        "tdg",
+        "x",
+        "cz",
+        "sdg",
+        "u1",
+        "p",
+        "ry",
+        "r",
+        "t",
+        "rx",
+        "sx"
+      ],
+      "is_symmetric_connectivity": true
+    },
+    "debug_mode": true,
+    "synthesize_all_separately": false,
+    "optimization_level": 3,
+    "output_format": [
+      "qasm"
+    ],
+    "pretty_qasm": true,
+    "transpilation_option": "auto optimize",
+    "timeout_seconds": 300,
+    "random_seed": 2608316458
+  }
+}
\ No newline at end of file
diff --git a/tests/resources/timeouts.yaml b/tests/resources/timeouts.yaml
index 0c9328115..cd5ff11b1 100644
--- a/tests/resources/timeouts.yaml
+++ b/tests/resources/timeouts.yaml
@@ -1,3 +1,4 @@
+Predicting_Many_Properties_of_a_Quantum_System_from_Very_Few_Measurements: 600
 3_sat_grover.ipynb: 36
 3_sat_grover.qmod: 48
 3_sat_grover_large.qmod: 10