ds_zne/ds_zne_data_gen_deeper_circs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cirq\n",
    "import mitiq\n",
    "import stim\n",
    "import stimcirq\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 2\n",
    "num_trials = 10\n",
    "p_err = 0.004\n",
    "p_th = 0.009\n",
    "base_shots = 10**4\n",
    "device_size = 1500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_array = np.linspace(27, 5, 12, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_noise_model(p_err, p_th, distance):\n",
    "    \"\"\"Create sweepable Pauli noise model.\"\"\"\n",
    "    LERR = 0.03 * (p_err / p_th) ** int((distance + 1) / 2)\n",
    "    return LERR # model as single-qubit errors remaining after correction "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PauliNoiseModel(cirq.NoiseModel):\n",
    "\n",
    "    def __init__(self, error_rate):\n",
    "        self.error_rate = error_rate\n",
    "\n",
    "    def noisy_operation(self, op):\n",
    "        error_rate = self.error_rate\n",
    "        channel = cirq.BitFlipChannel(error_rate).on_each(op.qubits)\n",
    "        channel += cirq.PhaseFlipChannel(error_rate).on_each(op.qubits)\n",
    "        return [op, channel]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fill_circuit(circ):\n",
    "    filled_circuit = cirq.Circuit()\n",
    "    qubits = circ.all_qubits()\n",
    "    for m in circ:\n",
    "        idle = False\n",
    "        for q in qubits:\n",
    "            if not m.operates_on_single_qubit(q):\n",
    "               idle = True\n",
    "               filled_circuit.append(m.with_operations(cirq.I(q)))\n",
    "               break\n",
    "        if not idle:\n",
    "          filled_circuit.append(m)\n",
    "\n",
    "    return filled_circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "cirq_circuits_depth100 = mitiq.benchmarks.generate_rb_circuits(n_qubits, num_cliffords=100, trials=num_trials)\n",
    "filled_circuits_depth100 = []\n",
    "for c in cirq_circuits_depth100:\n",
    "    filled_circuit = fill_circuit(c)\n",
    "    filled_circuit.append(cirq.measure(filled_circuit.all_qubits()))\n",
    "    filled_circuits_depth100.append(filled_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noisy_circuits_depth100 = []\n",
    "stim_circuits_depth100 = []\n",
    "for di in range(len(d_array)):\n",
    "    noisy_circuits_depth100 = [f.with_noise(PauliNoiseModel(gen_noise_model(p_err, p_th, d_array[di]))) for f in filled_circuits_depth100[:num_trials]]\n",
    "    stim_circuits_depth100.append([stimcirq.cirq_circuit_to_stim_circuit(n) for n in noisy_circuits_depth100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def batched_stim_executor(circ_list, shots):\n",
    "    noisy_expectation_values = []\n",
    "    for c in circ_list:\n",
    "        sampler = c.compile_sampler()\n",
    "        result = sampler.sample(shots=shots)\n",
    "        counts = np.count_nonzero([r[0].astype(int) + r[1].astype(int) for r in result])\n",
    "        noisy_expectation_values.append(1 - counts/shots)\n",
    "    return noisy_expectation_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_shots(num_device_qubits, scaled_distance, base_shots, n_qubits_circuit):\n",
    "    used_qubits = n_qubits_circuit * scaled_distance ** 2\n",
    "    return base_shots * int(num_device_qubits / used_qubits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_results_depth100 = np.zeros((num_trials, len(d_array)))\n",
    "for di in range(len(d_array)):\n",
    "    ds_results_depth100[:, di] = batched_stim_executor(stim_circuits_depth100[di], shots=scale_shots(device_size, d_array[di], base_shots, n_qubits))\n",
    "\n",
    "np.savetxt(\"data/ds_depth100.txt\", ds_results_depth100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "unmit_results_depth100 = np.zeros((num_trials, len(d_array)-3))\n",
    "for di in range(len(d_array)-3):\n",
    "    unmit_results_depth100[:, di] = batched_stim_executor(stim_circuits_depth100[di], shots=scale_shots(device_size, d_array[di], 4*base_shots, n_qubits))\n",
    "\n",
    "np.savetxt(\"data/unmit_depth100.txt\", unmit_results_depth100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cirq_circuits_depth1000 = mitiq.benchmarks.generate_rb_circuits(n_qubits, num_cliffords=1000, trials=num_trials)\n",
    "filled_circuits_depth1000 = []\n",
    "for c in cirq_circuits_depth1000:\n",
    "    filled_circuit = fill_circuit(c)\n",
    "    filled_circuit.append(cirq.measure(filled_circuit.all_qubits()))\n",
    "    filled_circuits_depth1000.append(filled_circuit)\n",
    "\n",
    "stim_circuits_depth1000 = [stimcirq.cirq_circuit_to_stim_circuit(f) for f in filled_circuits_depth1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stim_circuits_depth1000 = []\n",
    "for di in range(len(d_array)):\n",
    "    noisy_circuits_depth1000 = [f.with_noise(PauliNoiseModel(gen_noise_model(p_err, p_th, d_array[di]))) for f in filled_circuits_depth1000[:num_trials]]\n",
    "    stim_circuits_depth1000.append([stimcirq.cirq_circuit_to_stim_circuit(n) for n in noisy_circuits_depth1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_results_depth1000 = np.zeros((num_trials, len(d_array)))\n",
    "for di in range(len(d_array)):\n",
    "    ds_results_depth1000[:, di] = batched_stim_executor(stim_circuits_depth1000[di], shots=scale_shots(device_size, d_array[di], base_shots, n_qubits))\n",
    "\n",
    "np.savetxt(\"data/ds_depth1000.txt\", ds_results_depth1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "unmit_results_depth1000 = np.zeros((num_trials, len(d_array)-3))\n",
    "for di in range(len(d_array)-3):\n",
    "    unmit_results_depth1000[:, di] = batched_stim_executor(stim_circuits_depth1000[di], shots=scale_shots(device_size, d_array[di], 4*base_shots, n_qubits))\n",
    "\n",
    "np.savetxt(\"data/unmit_depth1000.txt\", unmit_results_depth1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "cirq_circuits_depth10k = mitiq.benchmarks.generate_rb_circuits(n_qubits, num_cliffords=10**4, trials=num_trials)\n",
    "filled_circuits_depth10k = []\n",
    "for c in cirq_circuits_depth10k:\n",
    "    filled_circuit = fill_circuit(c)\n",
    "    filled_circuit.append(cirq.measure(filled_circuit.all_qubits()))\n",
    "    filled_circuits_depth10k.append(filled_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stim_circuits_depth10k = []\n",
    "for di in range(len(d_array)):\n",
    "    noisy_circuits_depth10k = [f.with_noise(PauliNoiseModel(gen_noise_model(p_err, p_th, d_array[di]))) for f in filled_circuits_depth10k[:num_trials]]\n",
    "    stim_circuits_depth10k.append([stimcirq.cirq_circuit_to_stim_circuit(n) for n in noisy_circuits_depth10k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds_results_depth10k = np.zeros((num_trials, len(d_array)))\n",
    "for di in range(len(d_array)):\n",
    "    ds_results_depth10k[:, di] = batched_stim_executor(stim_circuits_depth10k[di], shots=scale_shots(device_size, d_array[di], base_shots, n_qubits))\n",
    "\n",
    "np.savetxt(\"data/ds_depth10000.txt\", ds_results_depth10k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "unmit_results_depth10k = np.zeros((num_trials, 3))\n",
    "for di in range(len(d_array) - 3):\n",
    "    unmit_results_depth10k[:, di] = batched_stim_executor(stim_circuits_depth10k[di], shots=scale_shots(device_size, d_array[di], 4*base_shots, n_qubits))\n",
    "\n",
    "np.savetxt(\"data/unmit_depth10000.txt\", unmit_results_depth10k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "scale_factors = [1, 3, 5, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_noise_to_stim_circuits(circuits, p_err, p_th, d):\n",
    "    noisy_stim_circuits = []\n",
    "    for c in range(len(circuits)):\n",
    "        noisy = stim.Circuit()\n",
    "        stim_circ = circuits[c]\n",
    "        for instruction in stim_circ:\n",
    "            noisy.append(instruction)\n",
    "            if instruction.name != \"TICK\":\n",
    "                noisy.append(\"X_ERROR\", instruction.targets_copy(), gen_noise_model(p_err, p_th, d))\n",
    "                noisy.append(\"Z_ERROR\", instruction.targets_copy(), gen_noise_model(p_err, p_th, d))\n",
    "        noisy_stim_circuits.append(noisy)\n",
    "    return noisy_stim_circuits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stim_folded_circuits_depth100 = []\n",
    "for s in scale_factors[1:]:\n",
    "    folded_circuits_depth100 = [mitiq.zne.scaling.fold_global(c, s) for c in filled_circuits_depth100]\n",
    "    stim_folded_circuits_depth100.append([stimcirq.cirq_circuit_to_stim_circuit(f) for f in folded_circuits_depth100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in d_array[:9]:\n",
    "    results = np.zeros((num_trials, 3))\n",
    "    for s in range(3):\n",
    "        noisy_circuits = add_noise_to_stim_circuits(stim_folded_circuits_depth100[s], p_err, p_th, d)\n",
    "        shots = scale_shots(device_size, d, base_shots, n_qubits)\n",
    "        results[:, s] = batched_stim_executor(noisy_circuits, shots)\n",
    "    np.savetxt(f\"/Users/mistywahl/Documents/GitHub/mitiq-internal/ds-zne/data/folding_depth100_d{d}\", results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stim_folded_circuits_depth1000 = []\n",
    "for s in scale_factors[1:]:\n",
    "    folded_circuits_depth1000 = [mitiq.zne.scaling.fold_global(c, s) for c in filled_circuits_depth1000]\n",
    "    stim_folded_circuits_depth1000.append([stimcirq.cirq_circuit_to_stim_circuit(f) for f in folded_circuits_depth1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in d_array[:9]:\n",
    "    results = np.zeros((num_trials, 3))\n",
    "    for s in range(3):\n",
    "        noisy_circuits = add_noise_to_stim_circuits(stim_folded_circuits_depth1000[s], p_err, p_th, d)\n",
    "        shots = scale_shots(device_size, d, base_shots, n_qubits)\n",
    "        results[:, s] = batched_stim_executor(noisy_circuits, shots)\n",
    "    np.savetxt(f\"/Users/mistywahl/Documents/GitHub/mitiq-internal/ds-zne/data/folding_depth1000_d{d}\", results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "stim_folded_circuits_depth10k = []\n",
    "for s in scale_factors[1:]:\n",
    "    folded_circuits_depth10k = [mitiq.zne.scaling.fold_global(c, s) for c in filled_circuits_depth10k]\n",
    "    stim_folded_circuits_depth10k.append([stimcirq.cirq_circuit_to_stim_circuit(f) for f in folded_circuits_depth10k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in d_array[:9]:\n",
    "    results = np.zeros((num_trials, 3))\n",
    "    for s in range(3):\n",
    "        noisy_circuits = add_noise_to_stim_circuits(stim_folded_circuits_depth10k[s], p_err, p_th, d)\n",
    "        shots = scale_shots(device_size, d, base_shots, n_qubits)\n",
    "        results[:, s] = batched_stim_executor(noisy_circuits, shots)\n",
    "    np.savetxt(f\"data/folding_depth10000_d{d}\", results)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "992c44e14009e3623432b51dfa0ccb8179e6507fb1569359de12ac98f26b40e8"
  },
  "kernelspec": {
   "display_name": "Python 3.8.13 64-bit ('venv_mitiq_learnrepspec')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}