model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "61b5710b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from qctrlvisualizer import get_qctrl_style, plot_controls\n",
    "\n",
    "from qctrl import Qctrl\n",
    "\n",
    "plt.style.use(get_qctrl_style())\n",
    "\n",
    "# Sparse matrix imports\n",
    "from scipy.sparse import coo_matrix\n",
    "\n",
    "# Starting a session with the API\n",
    "qctrl = Qctrl()\n",
    "\n",
    "\n",
    "sigma_x = np.array([[0, 1], [1, 0]])\n",
    "sigma_z = np.array([[1, 0], [0, -1]])\n",
    "sigma_y = np.array([[0, -1j], [1j, 0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5efa722",
   "metadata": {},
   "source": [
    "Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "da8e4705",
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_pulse(H, nodes, noise, target_operation):\n",
    "    infidelity = qctrl.operations.infidelity_pwc(\n",
    "        hamiltonian=H,\n",
    "        noise_operators=noise,\n",
    "        target_operator=target_operation,\n",
    "        name=\"infidelity\",\n",
    "    )\n",
    "    optimization_result = qctrl.functions.calculate_optimization(\n",
    "        cost_node_name=\"infidelity\",\n",
    "        output_node_names=nodes,\n",
    "        graph=graph,\n",
    "    )\n",
    "    \n",
    "    return optimization_result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2f986a5",
   "metadata": {},
   "source": [
    "Ideal simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1ce4c27e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_ideal_qubit(duration, values, shots, repetitions):\n",
    "    b = np.array([[0, 1], [0, 0]])  # Lowering operator\n",
    "    initial_state = np.array([[1], [0]])  # Initial state of qubit in |0>\n",
    "\n",
    "    with qctrl.create_graph() as graph:\n",
    "        drive = qctrl.operations.pwc_signal(duration=duration, values=values)\n",
    "        hamiltonian = qctrl.operations.pwc_operator_hermitian_part(\n",
    "            qctrl.operations.pwc_operator(signal=drive, operator=b)\n",
    "        )\n",
    "        unitary = qctrl.operations.time_evolution_operators_pwc(\n",
    "            hamiltonian=hamiltonian,\n",
    "            sample_times=np.array([duration]),\n",
    "        )[-1]\n",
    "        unitary.name = \"unitary\"\n",
    "\n",
    "        repeated_unitary = np.eye(2)\n",
    "        for _ in range(repetitions):\n",
    "            repeated_unitary = repeated_unitary @ unitary\n",
    "        repeated_unitary.name = \"repeated_unitary\"\n",
    "\n",
    "        state = repeated_unitary @ initial_state\n",
    "\n",
    "        populations = qctrl.operations.abs(state[:, 0]) ** 2\n",
    "        norm = qctrl.operations.sum(populations)\n",
    "        populations = populations / norm\n",
    "        populations.name = \"populations\"\n",
    "\n",
    "        result = qctrl.functions.calculate_graph(\n",
    "            graph=graph,\n",
    "            output_node_names=[\"unitary\", \"repeated_unitary\", \"populations\"],\n",
    "        )\n",
    "\n",
    "    unitary = result.output[\"unitary\"][\"value\"]\n",
    "    repeated_unitary = result.output[\"repeated_unitary\"][\"value\"]\n",
    "    populations = result.output[\"populations\"][\"value\"]\n",
    "\n",
    "    measurements = np.random.choice(2, size=shots, p=populations)\n",
    "\n",
    "    results = {\"unitary\": unitary, \"measurements\": measurements}\n",
    "\n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37b65554",
   "metadata": {},
   "source": [
    "Ideal qubit, only drive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "522a19d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your task calculate_optimization has started.\n",
      "Your task calculate_optimization has completed in 6s.\n"
     ]
    }
   ],
   "source": [
    "duration = 5\n",
    "segment_count = 10\n",
    "\n",
    "with qctrl.create_graph() as graph:\n",
    "    #Drive\n",
    "    b = np.array([[0, 1], [0, 0]])  # Lowering operator\n",
    "    gamma = qctrl.operations.complex_pwc_signal(\n",
    "        moduli=qctrl.operations.anchored_difference_bounded_variables(\n",
    "            count=segment_count,\n",
    "            lower_bound=-1,\n",
    "            upper_bound=1,\n",
    "            difference_bound=0.5,\n",
    "        ),\n",
    "        phases=qctrl.operations.unbounded_optimization_variable(\n",
    "            count=segment_count,\n",
    "            initial_lower_bound=0,\n",
    "            initial_upper_bound=2 * np.pi,\n",
    "        ),\n",
    "        duration=duration,\n",
    "        name=\"gamma\",\n",
    "    )\n",
    "    drive = qctrl.operations.pwc_operator_hermitian_part(\n",
    "        qctrl.operations.pwc_operator(signal=gamma, operator=b)\n",
    "    )\n",
    "    \n",
    "    # Hadamard gate\n",
    "    ideal_h_gate = (1 / np.sqrt(2)) * np.array([[1, 1], [1, -1]])\n",
    "    ideal_not = np.array([[0,1], [1,0]])\n",
    "    target_op = qctrl.operations.target(operator=ideal_not)\n",
    "\n",
    "    \n",
    "    H = qctrl.operations.pwc_sum([drive])\n",
    "\n",
    "    #target_op = qctrl.operations.target(operator=target_op)\n",
    "\n",
    "    optimization_result = optimize_pulse(H, [\"gamma\"], [], target_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f9e3de7",
   "metadata": {},
   "source": [
    "Check pulse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "52febb08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_controls(\n",
    "    plt.figure(),\n",
    "    controls={\n",
    "        \"$\\\\gamma$\": optimization_result.output[\"gamma\"],\n",
    "    },\n",
    ")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51fcd42f",
   "metadata": {},
   "source": [
    "Simulate with ideal qubit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c93629bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your task calculate_graph has completed in 3s.\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "IQ = np.array([o.get(\"value\") for o in optimization_result.output[\"gamma\"]])\n",
    "\n",
    "shots = 3000\n",
    "\n",
    "IQ = np.array(list(IQ) + list(IQ))\n",
    "\n",
    "result = simulate_ideal_qubit(duration, IQ, shots, 1)\n",
    "print(sum(result.get(\"measurements\"))/shots)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "713d2b6f",
   "metadata": {},
   "source": [
    "## \"Real\" device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf031d80",
   "metadata": {},
   "source": [
    "Fuction to test on simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3b1b3d56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_IQ(IQ, duration, segments, shot_count):\n",
    "    controls = []\n",
    "    values = IQ\n",
    "    control_seq = {\n",
    "        \"duration\": 10, \n",
    "        \"values\":values,\n",
    "        \"repetition_count\": 1\n",
    "    }\n",
    "    controls.append(control_seq)\n",
    "    plot_controls(\n",
    "        figure=plt.figure(),\n",
    "        controls={\n",
    "            \"$\\Omega$\": [\n",
    "                {\"duration\": duration/segments, \"value\": value} for value in values\n",
    "            ]\n",
    "        },\n",
    "    )\n",
    "    \n",
    "    experiment_results = qctrl.functions.calculate_qchack_measurements(\n",
    "        controls=controls,\n",
    "        shot_count=shot_count,\n",
    "    )\n",
    "    \n",
    "    return experiment_results.measurements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "664f7119",
   "metadata": {},
   "source": [
    "Function that runs the optimizer based on the model, change values in the beginning depending on model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "93ee0153",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your task calculate_optimization has started.\n",
      "Your task calculate_optimization has completed in 15s.\n",
      "Optimized cost:\t 2.388161423516821e-05\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your task calculate_qchack_measurements has completed in 3s.\n",
      "0.4816666666666667\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "shot_count = 3000\n",
    "\n",
    "duration = 100\n",
    "segment_count = 10\n",
    "const_X_ampl = 0.01\n",
    "const_Y_ampl = 0.01\n",
    "const_Z_ampl = 0.1\n",
    "sigma = 0.5\n",
    "mu = 31.65\n",
    "\n",
    "T1 = 0.01\n",
    "T2 = 0.1\n",
    "\n",
    "with qctrl.create_graph() as graph:\n",
    "    #Drive\n",
    "    b = np.array([[0, 1], [0, 0]])  # Lowering operator\n",
    "\n",
    "    gamma = qctrl.operations.complex_pwc_signal(\n",
    "        #moduli=drive_mod_filtered,\n",
    "        moduli=qctrl.operations.anchored_difference_bounded_variables(\n",
    "            count=segment_count,\n",
    "            lower_bound=-1,\n",
    "            upper_bound=1,\n",
    "            difference_bound=0.5,\n",
    "        ),\n",
    "        phases=qctrl.operations.unbounded_optimization_variable(\n",
    "            count=segment_count,\n",
    "            initial_lower_bound=0,\n",
    "            initial_upper_bound=2 * np.pi,\n",
    "        ),\n",
    "        duration=duration,\n",
    "        name=\"gamma\",\n",
    "    )\n",
    "\n",
    "    drive_filtered = qctrl.operations.convolve_pwc(\n",
    "        gamma,\n",
    "        qctrl.operations.gaussian_integral_function(std=sigma, offset=mu),\n",
    "    )\n",
    "\n",
    "    drive_disc = qctrl.operations.discretize_stf(\n",
    "            drive_filtered, duration=duration, segments_count=segment_count\n",
    "        )\n",
    "\n",
    "    drive = qctrl.operations.pwc_operator_hermitian_part(\n",
    "        qctrl.operations.pwc_operator(signal=gamma, operator=b)\n",
    "    )\n",
    "\n",
    "    # Const x\n",
    "    const_X = qctrl.operations.constant_pwc_operator(\n",
    "        duration=duration,\n",
    "        operator=const_X_ampl * sigma_x / 2,\n",
    "    )\n",
    "\n",
    "    # Const z\n",
    "    const_Z = qctrl.operations.constant_pwc_operator(\n",
    "        duration=duration,\n",
    "        operator=const_Z_ampl * sigma_z / 2,\n",
    "    )\n",
    "\n",
    "    # Const y\n",
    "    const_Y = qctrl.operations.constant_pwc_operator(\n",
    "        duration=duration,\n",
    "        operator=const_Y_ampl * sigma_y / 2,\n",
    "    )\n",
    "\n",
    "\n",
    "    # T2\n",
    "    dephasing = qctrl.operations.constant_pwc_operator(\n",
    "        duration=duration, operator=T2 * sigma_z / duration\n",
    "    )\n",
    "\n",
    "    # T1\n",
    "    depolarisation = qctrl.operations.constant_pwc_operator(\n",
    "        duration=duration, operator=T1 * b\n",
    "    )\n",
    "\n",
    "    # taget gate matrices\n",
    "    ideal_h_gate = (1 / np.sqrt(2)) * np.array([[1, 1], [1, -1]])\n",
    "    ideal_not = np.array([[0, 1], [1, 0]])\n",
    "\n",
    "    #target_op = qctrl.operations.target(operator=ideal_not)\n",
    "    target_op = qctrl.operations.target(operator=ideal_h_gate)\n",
    "\n",
    "\n",
    "    H = qctrl.operations.pwc_sum([drive, const_X, const_Y, const_Z])\n",
    "\n",
    "    optimization_result = optimize_pulse(H, [\"gamma\"], [dephasing, depolarisation], target_op)\n",
    "    print(\"Optimized cost:\\t\", optimization_result.cost)\n",
    "\n",
    "# IQ - the np.array of IQ values\n",
    "IQ = np.array([o.get(\"value\") for o in optimization_result.output[\"gamma\"]])\n",
    "results = test_IQ(IQ, duration, segment_count, shot_count)\n",
    "print(sum(results[0])/shot_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cb167e6",
   "metadata": {},
   "source": [
    "To check the same pulses again without running the optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "676d8727",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your task calculate_qchack_measurements has completed in 3s.\n",
      "0.5093333333333333\n"
     ]
    }
   ],
   "source": [
    "shot_count = 3000\n",
    "def test_IQ(IQ, dur, seg, shot_count):\n",
    "    controls = []\n",
    "    values = IQ\n",
    "    control_seq = {\n",
    "        \"duration\": dur, \n",
    "        \"values\":values,\n",
    "        \"repetition_count\": 1\n",
    "    }\n",
    "    controls.append(control_seq)\n",
    "    \n",
    "    \n",
    "    experiment_results = qctrl.functions.calculate_qchack_measurements(\n",
    "        controls=controls,\n",
    "        shot_count=shot_count,\n",
    "    )\n",
    "    \n",
    "    return experiment_results.measurements\n",
    "\n",
    "\n",
    "results = test_IQ(IQ, duration, segment_count, shot_count)\n",
    "print(sum(results[0])/shot_count)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "qchack",
   "language": "python",
   "name": "qchack"
  },
  "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}