AIDE-QC-Demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "imposed-banks",
   "metadata": {},
   "source": [
    "# BQSKit Demo for AIDE-QC All Hands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "romance-killer",
   "metadata": {},
   "source": [
    "This demo is performed with:\n",
    "- Python 3.9.3\n",
    "- QSearch 2.5.0\n",
    "- QFAST 2.2.0\n",
    "- QFactor 1.0.1\n",
    "\n",
    "Can be installed by pip: `pip install qsearch qfast qfactor`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "painted-seven",
   "metadata": {},
   "source": [
    "## General Synthesis with QSearch + LEAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "japanese-drama",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qsearch import options, leap_compiler, compiler, post_processing, assemblers, unitaries\n",
    "\n",
    "# Pass options into qsearch and set the target to utry\n",
    "opts = options.Options()\n",
    "opts.target = unitaries.qft(8)  # Synthesize 3-qubit unitary\n",
    "opts.verbosity = 0              # Don't log\n",
    "opts.write_to_stdout = False    # Don't print log messages to stdout\n",
    "opts.reoptimize_size = 7        # Reoptimization window\n",
    "\n",
    "# Use the LEAP compiler\n",
    "compiler = leap_compiler.LeapCompiler()\n",
    "output = compiler.compile(opts)\n",
    "\n",
    "# LEAP's Reoptimization as QSearch post-processing\n",
    "pp = post_processing.LEAPReoptimizing_PostProcessor()\n",
    "output = pp.post_process_circuit(output, opts)\n",
    "qasm_str = assemblers.ASSEMBLER_IBMOPENQASM.assemble(output)\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aging-committee",
   "metadata": {},
   "source": [
    "### Changing topology"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "interior-halloween",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qsearch import gatesets\n",
    "\n",
    "# Set to topology to all-to-all, qsearch defaults to linear.\n",
    "opts.gateset = gatesets.QubitCNOTAdjacencyList([(0,1),(0,2),(1,2)])\n",
    "\n",
    "# Recompile and reoptimize\n",
    "compiler = leap_compiler.LeapCompiler()\n",
    "output = compiler.compile(opts)\n",
    "pp = post_processing.LEAPReoptimizing_PostProcessor()\n",
    "output = pp.post_process_circuit(output, opts)\n",
    "qasm_str = assemblers.ASSEMBLER_IBMOPENQASM.assemble(output)\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accessory-saskatchewan",
   "metadata": {},
   "source": [
    "### Different Gatesets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "brown-holmes",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set gateset to different one\n",
    "# opts.gateset = gatesets.QubitCZLinear()  # CZ Gates\n",
    "opts.gateset = gatesets.QubitXXLinear()  # XX Gates\n",
    "# opts.gateset = gatesets.QubitISwapLinear()  # ISwap Gates\n",
    "\n",
    "# Recompile and reoptimize\n",
    "compiler = leap_compiler.LeapCompiler()\n",
    "output = compiler.compile(opts)\n",
    "pp = post_processing.LEAPReoptimizing_PostProcessor()\n",
    "output = pp.post_process_circuit(output, opts)\n",
    "qasm_str = assemblers.ASSEMBLER_IBMOPENQASM.assemble(output)\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "false-thought",
   "metadata": {},
   "source": [
    "### Optimizer Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "initial-confidence",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qsearch import solvers, multistart_solvers, parallelizers\n",
    "\n",
    "# Reoptimization window\n",
    "opts.reoptimize_size = 5\n",
    "\n",
    "# Multistart Solver\n",
    "opts.solver = multistart_solvers.MultiStart_Solver(8)\n",
    "opts.parallelizer = parallelizers.ProcessPoolParallelizer\n",
    "\n",
    "# Recompile and reoptimize\n",
    "compiler = leap_compiler.LeapCompiler()\n",
    "output = compiler.compile(opts)\n",
    "pp = post_processing.LEAPReoptimizing_PostProcessor()\n",
    "output = pp.post_process_circuit(output, opts)\n",
    "qasm_str = assemblers.ASSEMBLER_IBMOPENQASM.assemble(output)\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "greenhouse-dance",
   "metadata": {},
   "source": [
    "### With logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "written-hartford",
   "metadata": {},
   "outputs": [],
   "source": [
    "opts.verbosity = 2\n",
    "opts.write_to_stdout = True\n",
    "\n",
    "\n",
    "# Recompile and reoptimize\n",
    "compiler = leap_compiler.LeapCompiler()\n",
    "output = compiler.compile(opts)\n",
    "pp = post_processing.LEAPReoptimizing_PostProcessor()\n",
    "output = pp.post_process_circuit(output, opts)\n",
    "qasm_str = assemblers.ASSEMBLER_IBMOPENQASM.assemble(output)\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "figured-dealer",
   "metadata": {},
   "source": [
    "## General Synthesis with QFAST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "framed-minneapolis",
   "metadata": {},
   "outputs": [],
   "source": [
    "import qfast\n",
    "\n",
    "qasm_str = qfast.synthesize(unitaries.qft(8))  # Synthesize qft3\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "canadian-nancy",
   "metadata": {},
   "source": [
    "### Changing topology"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sunset-directory",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set to linear topology, defaults to all-to-all\n",
    "qasm_str = qfast.synthesize(unitaries.qft(8), coupling_graph = [(0,1),(1,2)])\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "theoretical-situation",
   "metadata": {},
   "source": [
    "### Different Gatesets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "changed-cardiff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set to cz gates, defaults to cx, can also take iswap and rxx\n",
    "qasm_str = qfast.synthesize(unitaries.qft(8), basis_gates = ['cz'])\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indian-pressure",
   "metadata": {},
   "source": [
    "### Optimizer Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "short-vietnam",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set success threshold\n",
    "qasm_str = qfast.synthesize(unitaries.qft(8), model_options = {\"success_threshold\": 1e-6})\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neural-creativity",
   "metadata": {},
   "source": [
    "### Block size settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afraid-receipt",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use different block sizes\n",
    "# Default hierarchy fn = lambda x : x // 3 if x > 5 else 2\n",
    "qasm_str = qfast.synthesize(unitaries.qft(16), hierarchy_fn = lambda x : 3)  # 3-qubit blocks\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fresh-heather",
   "metadata": {},
   "source": [
    "### With logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "third-advice",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Enable qfast logging\n",
    "import logging\n",
    "logging.getLogger( \"qfast\" ).setLevel( logging.INFO )\n",
    "\n",
    "qasm_str = qfast.synthesize(unitaries.qft(16))  # Synthesize qft4\n",
    "print(qasm_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proprietary-humanitarian",
   "metadata": {},
   "source": [
    "## Circuit Template Instantiation with QFactor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "textile-worth",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Optimize a 3-qubit circuit to be a toffoli gate.\"\"\"\n",
    "\n",
    "import numpy as np\n",
    "from scipy.stats import unitary_group\n",
    "\n",
    "from qfactor import Gate, optimize, get_distance\n",
    "\n",
    "\n",
    "# The next two lines start qfactor's logger.\n",
    "import logging\n",
    "logging.getLogger( \"qfactor\" ).setLevel( logging.INFO )\n",
    "\n",
    "# We will optimize towards the toffoli unitary.\n",
    "toffoli = np.array( [ [ 1, 0, 0, 0, 0, 0, 0, 0 ],\n",
    "                      [ 0, 1, 0, 0, 0, 0, 0, 0 ],\n",
    "                      [ 0, 0, 1, 0, 0, 0, 0, 0 ],\n",
    "                      [ 0, 0, 0, 1, 0, 0, 0, 0 ],\n",
    "                      [ 0, 0, 0, 0, 1, 0, 0, 0 ],\n",
    "                      [ 0, 0, 0, 0, 0, 1, 0, 0 ],\n",
    "                      [ 0, 0, 0, 0, 0, 0, 0, 1 ],\n",
    "                      [ 0, 0, 0, 0, 0, 0, 1, 0 ] ] )\n",
    "\n",
    "# Start with the circuit structure\n",
    "# and an initial guess for the gate's unitaries.\n",
    "# Here we use randomly generated unitaries for initial guess.\n",
    "circuit = [ Gate( unitary_group.rvs(4), (1, 2) ),\n",
    "            Gate( unitary_group.rvs(4), (0, 2) ),\n",
    "            Gate( unitary_group.rvs(4), (1, 2) ),\n",
    "            Gate( unitary_group.rvs(4), (0, 2) ),\n",
    "            Gate( unitary_group.rvs(4), (0, 1) ) ]\n",
    "\n",
    "# Note: the Gate object also has an optional boolean parameter \"fixed\"\n",
    "# If \"fixed\" is set to true, that gate's unitary will not change.\n",
    "\n",
    "# Call the optimize function\n",
    "ans = optimize( circuit, toffoli, # <--- These are the only required args\n",
    "                diff_tol_a = 1e-12,   # Stopping criteria for distance change\n",
    "                diff_tol_r = 1e-6,    # Relative criteria for distance change\n",
    "                dist_tol = 1e-12,     # Stopping criteria for distance\n",
    "                max_iters = 100000,   # Maximum number of iterations\n",
    "                min_iters = 1000,     # Minimum number of iterations\n",
    "                slowdown_factor = 0 ) # Larger numbers slowdown optimization\n",
    "                                      # to avoid local minima\n",
    "\n",
    "\n",
    "# The result \"ans\" is another circuit object (list[Gate])\n",
    "# with the gate's unitaries changed from the input circuit.\n",
    "print( \"Circuit: \", ans )\n",
    "print( \"Final Distance: \", get_distance( ans, toffoli ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hindu-mailman",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}