From 88564044eedabc11645e83b47855e4e9d2756ea5 Mon Sep 17 00:00:00 2001
From: Isil Ozfidan <iozfidan@dwavesys.com>
Date: Mon, 5 Mar 2018 15:14:47 -0800
Subject: [PATCH] 4/4! - transform functions. (#232)

* fixed bohr/angstrom confusion in function description

* translations from mathematica to python arxiv1712.07067

* work on those notimplementeds

* WIP: decoder class adittion

* modified decoder class. extractor implemented

* no need for pauliaction function

* introduction of symbolic binary class - no more decoder class

* minor bugs fixed, applies binary rules to input now

* started programming the BinaryCode class, work in progress

* added count qubit function in binary operator, modified code.py

* fixed morning brain bugs

* implemented concatination and appending, not yet documented and debugged

* added _shift function to symbolicBinary and integer addition. modified the decoder shifter accordinly

* radd imul, NOT TESTED! - just copy paste should work?

* fixed small bugs, added default codes, created transform

* fixed the multiplication error and modified the transform code following mathematica code. it was giving wrong operators before, now the operators are fine but signs are wonky

* fixed the transform and all the places where we accidentally started to count qubit/fermion labels from 1 instead of 0

* bug fixes: ordering matters to detect which terms should cancel

* fixed code appending, introduced the integer multiplication (left+right) as a tool to append the same code intance several times

* modified the multiply by 0 and 1 behavior in SymbolicBinary. added tests for symbolicBinary. minor mods for python3 comp.

* fixed the condition for code concatenation, fixed a bug in checksum_code, added an error if qubit index in a code is out of bounds

* added comments to binary_operator, more test, evaluate function

* started writing documentations and clipping lines, writing out numpy

* merging with the merger

* updating binary operator based on comments

* updating the binary_ops

* updates based on comments

* init update

* moved binaryop to first import

* added names into notice and readme

* started documentation in  _code_operator.py, added parity code / (K=1) and (K=2) segment code / K=1 binary addressing code

* encoders are sparse matrices now

* added tests for code_operator

* doc strings for the transform, fixed bug in the initialization of SymbolicBinary, made changes suggested by review, carried some of them over to files to be pulled later

* updates based on pull request comments

* merging changes with merger

* fixing possible integer checking errors

* cleaned version of transform function, needs testing and timing - seems to work so far

* fixed BK transforms. indexing errors

* added tests, pep8 and Ryan compliance mods

* added some style to the functions file

* renaming, re-structuring

* renaming again

* minor changes

* pep8

* changed the symbolicBInary class

* docstring cleanup

* bug docstring fixes

* bug fix in the evaluate method, pep8 the _binary_operator file

* merge with upstream and additional tests to SymbolicBinary class

* added weight-two segment code test, fixed bug with in the code appending by integer multiplication

* added half-up code

* bugs fixed in half-up code

* corrected weight_one_segment_code and the interleaved_code, former half-up. Added tests for the codes.

* get rid of heads

* reordering function for the fermionOperator class. takes 0,1,2,3,4,.. -> 0,2,4,..,1,3,...

* spin indexing within moleculardata

* started writing demo (work in progress), corrected typo in functions test , fixed possible bug for string parsing in symbolic binary file

* changed function file test such that data is obtained half-up, added last part for ipython demo

* corrected typos in the demo notebook

* fixed bugs in test, it now runs without error

* code transforms

* pep8

* transform demo

* fixes

* typos fixing in demo

* reverting back to original demo

* demo testing & indent

* docstring update

* not ready for review! started on docs

* descriptions for code functions

* final pass at docs, fixing spaces

* modes to n modes, and imports

* fixed a bug in demo, added description to weight-n codes
---
 examples/binary_code_transforms_demo.ipynb    | 346 ++++++++++++++++++
 .../hamiltonians/_molecular_data.py           |   6 +-
 src/openfermion/ops/_symbolic_binary.py       |   2 +-
 src/openfermion/tests/_example_test.py        |  32 ++
 src/openfermion/transforms/__init__.py        |   8 +
 src/openfermion/transforms/_bravyi_kitaev.py  |   1 +
 .../transforms/_code_transform_functions.py   | 258 +++++++++++++
 .../_code_transform_functions_test.py         | 100 +++++
 8 files changed, 749 insertions(+), 4 deletions(-)
 create mode 100644 examples/binary_code_transforms_demo.ipynb
 create mode 100644 src/openfermion/transforms/_code_transform_functions.py
 create mode 100644 src/openfermion/transforms/_code_transform_functions_test.py

diff --git a/examples/binary_code_transforms_demo.ipynb b/examples/binary_code_transforms_demo.ipynb
new file mode 100644
index 000000000..ade753809
--- /dev/null
+++ b/examples/binary_code_transforms_demo.ipynb
@@ -0,0 +1,346 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This code block is for automatic testing purposes, please ignore.\n",
+    "try:\n",
+    "    import openfermion\n",
+    "except:\n",
+    "    import os\n",
+    "    os.chdir('../src/')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "# Lowering qubit requirements using binary codes\n",
+    "## Introduction\n",
+    "\n",
+    "Molecular Hamiltonians are known to have certain symmetries that are not taken into account by mappings like the Jordan-Wigner or Bravyi-Kitaev transform. The most notable of such symmetries is the conservation of the total number of particles in the system. Since those symmetries effectively reduce the degrees of freedom of the system, one is able to reduce the number of qubits required for simulation by utilizing binary codes (arXiv:1712.07067). \n",
+    "\n",
+    "We can represent the symmetry-reduced Fermion basis by binary vectors of a set $\\mathcal{V} \\ni \\boldsymbol{\\nu}$, with $ \\boldsymbol{\\nu} = (\\nu_0, \\, \\nu_1, \\dots, \\, \\nu_{N-1} ) $, where every component $\\nu_i \\in \\lbrace 0, 1 \\rbrace $ and $N$ is the total number of Fermion modes.  These binary vectors $ \\boldsymbol{\\nu}$ are related to the actual basis states by: $$\n",
+    "\\left[\\prod_{i=0}^{N-1} (a_i^{\\dagger})^{\\nu_i}  \\right] \\left|{\\text{vac}}\\right\\rangle \\, ,\n",
+    "$$ where $ (a_i^\\dagger)^{0}=1$. The qubit basis, on the other hand, can be characterized by length-$n$ binary vectors $\\boldsymbol{\\omega}=(\\omega_0, \\, \\dots , \\, \\omega_{n-1})$, that represent an $n$-qubit basis state by:\n",
+    "$$ \\left|{\\omega_0}\\right\\rangle  \\otimes \\left|\\omega_1\\right\\rangle \\otimes \\dots \\otimes  \\left|{\\omega_{n-1}}\\right\\rangle \\, .  $$ \n",
+    "Since $\\mathcal{V}$ is a mere subset of the $N$-fold binary space, but the set of the vectors $\\boldsymbol{\\omega}$ spans the entire $n$-fold binary space we can assign every vector $\\boldsymbol{\\nu}$ to a vector $ \\boldsymbol{\\omega}$, such that $n<N$. This reduces the amount of qubits required by $(N-n)$. The mapping can be done by a binary code, a classical object that consists of an encoder function $\\boldsymbol{e}$ and a decoder function $\\boldsymbol{d}$. \n",
+    "These functions relate the binary vectors $\\boldsymbol{e}(\\boldsymbol{\\nu})=\\boldsymbol{\\omega}$, $\\boldsymbol{d}(\\boldsymbol{\\omega})=\\boldsymbol{\\nu}$, such that $\\boldsymbol{d}(\\boldsymbol{e}(\\boldsymbol{\\nu}))=\\boldsymbol{\\nu}$.\n",
+    "In OpenFermion, we, at the moment, allow for non-linear decoders $\\boldsymbol{d}$ and linear encoders $\\boldsymbol{e}(\\boldsymbol{\\nu})=A \\boldsymbol{\\nu}$, where the matrix multiplication with the $(n\\times N)$-binary matrix $A$ is $(\\text{mod 2})$ in every component. \n",
+    "\n",
+    "## Symbolic binary functions\n",
+    "\n",
+    "The non-linear binary functions for the components of the decoder are here modeled by the $\\text{SymbolicBinary}$ class in openfermion.ops.\n",
+    "For initialization we can conveniently use strings ('w0 w1 + w1 +1' for the binary function $\\boldsymbol{\\omega} \\to \\omega_0 \\omega_1 + \\omega_1 + 1 \\;\\text{mod 2}$), the native data structure or symbolic addition and multiplication."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "from openfermion.ops import SymbolicBinary\n",
+    "\n",
+    "binary_1 = SymbolicBinary('w0 w1 + w1 + 1')\n",
+    "\n",
+    "print(\"These three expressions are equivalent: \\n\", binary_1)\n",
+    "print(SymbolicBinary('w0') * SymbolicBinary('w1 + 1') + SymbolicBinary('1'))\n",
+    "print(SymbolicBinary([(1, 0), (1, ), ('one', )]))\n",
+    "\n",
+    "print('The native data type structure can be seen here:')\n",
+    "print(binary_1.terms)\n",
+    "print('We can always evaluate the expression for instance by the vector (w0, w1, w2) = (1, 0, 0):',\n",
+    "      binary_1.evaluate('100'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "code_folding": [
+     0.0
+    ],
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "## Binary codes\n",
+    "The $\\text{BinaryCode}$ class bundles a decoder - a list of decoder components, which are instances of $\\text{SymbolicBinary}$ - and an encoder - the matrix $A$ as sparse numpy array -  as a binary code. The constructor however admits (dense) numpy arrays, nested lists or tuples as input for $A$, and arrays, lists or tuples of $\\text{SymbolicBinary}$ objects - or valid inputs for $\\text{SymbolicBinary}$ constructors - as input for $\\boldsymbol{d}$. An instance of the $\\text{BinaryCode}$ class knows about the number of qubits and the number of modes in the mapping.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "from openfermion.ops import BinaryCode\n",
+    "\n",
+    "code_1 = BinaryCode([[1, 0, 0], [0, 1, 0]], ['w0', 'w1', 'w0 + w1 + 1' ])\n",
+    "\n",
+    "print(code_1)\n",
+    "print('number of qubits: ', code_1.n_qubits, '  number of Fermion modes: ', code_1.n_modes )\n",
+    "print('encoding matrix: \\n', code_1.encoder.toarray())\n",
+    "print('decoder: ', code_1.decoder)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "The code used in the example above, is in fact the (odd) Checksum code, and is implemented already - along with a few other examples from arxiv:1712.07067. In addition to the $\\text{checksum_code}$ the functions $\\text{weight_one_segment_code}$, $\\text{weight_two_segment_code}$, that output a subcode each, as well as $\\text{weight_one_binary_addressing_code}$ can be found under openfermion.transforms._code_transform_functions.\n",
+    "\n",
+    "There are two other ways to construct new codes from the ones given - both of them can be done conveniently with symbolic operations between two code objects $(\\boldsymbol{e}, \\boldsymbol{d})$ and $(\\boldsymbol{e^\\prime}, \\boldsymbol{d^\\prime})$ to yield a new code $(\\boldsymbol{e^{\\prime\\prime}}, \\boldsymbol{d^{\\prime\\prime}})$:  \n",
+    "  \n",
+    "**Appendage**  \n",
+    "Input and output vectors of two codes are appended to each other such that:\n",
+    "$$ e^{\\prime\\prime}(\\boldsymbol{\\nu} \\oplus \\boldsymbol{\\nu^{\\prime} })=\\boldsymbol{e}(\\boldsymbol{\\nu}) \\oplus \\boldsymbol{e^\\prime}(\\boldsymbol{\\nu^\\prime})\\, ,  \\qquad d^{\\prime\\prime}(\\boldsymbol{\\omega} \\oplus \\boldsymbol{\\omega^{\\prime} })=\\boldsymbol{d}(\\boldsymbol{\\omega}) \\oplus \\boldsymbol{d^\\prime}(\\boldsymbol{\\omega^\\prime}) \\, . $$\n",
+    "This is implemented with symbolic addition of two $\\text{BinaryCode}$ objects (using + or += ) or, for appending several instances of the same code at once, multiplication of the $\\text{BinaryCode}$ with an integer. Appending codes is useful when we want to obtain a segment code, or a segmented transform.\n",
+    "  \n",
+    "**Concatenation**  \n",
+    "Two codes can (if the corresponding vectors match in size) be applied consecutively, in the sense that the output of the encoder of the first code is input to the encoder of the second code. This defines an entirely new encoder, and the corresponding decoder is defined to undo this operation. \n",
+    "$$ \\boldsymbol{e^{\\prime\\prime}}(\\boldsymbol{\\nu^{\\prime\\prime}})=\\boldsymbol{e^\\prime}\\left(\\boldsymbol{e}(\\boldsymbol{\\nu^{\\prime\\prime}}) \\right) \\, , \\qquad \\boldsymbol{d^{\\prime\\prime}}(\\boldsymbol{\\omega^{\\prime\\prime}})=\\boldsymbol{d}\\left(\\boldsymbol{d^\\prime}(\\boldsymbol{\\omega^{\\prime\\prime}}) \\right)\n",
+    "$$\n",
+    "This is done by symbolic multiplication of two $\\text{BinaryCode}$ instances (with \\* or \\*=  ). One can concatenate the codes with each other such that additional qubits can be saved (e.g. checksum code \\* segment code ), or to modify the resulting gates after transform (e.g. checksum code \\* Bravyi-Kitaev code).  \n",
+    "\n",
+    "A broad palette of codes is provided to help construct codes symbolically. \n",
+    "The $\\text{jordan_wigner_code}$ can be appended to every code to fill the number of modes, concatenating the $\\text{bravyi_kitaev_code}$ or $\\text{parity_code}$ will modify the appearance of gates after the transform. The $\\text{interleaved_code}$ is useful to concatenate appended codes with if in Hamiltonians, Fermion operators are ordered by spin indexing even-odd (up-down-up-down-up ...) . This particular instance is used in the demonstration below.   \n",
+    "\n",
+    "Before we turn to describe the transformation, a word of warning has to be spoken here. Controlled gates that occur in the Hamiltonian by using non-linear codes are decomposed into Pauli strings, e.g. $\\text{CPHASE}(1,2)=\\frac{1}{2}(1+Z_1+Z_2-Z_1Z_2)$. In that way the amount of terms in a Hamiltonian might rise exponentially, if one chooses to use strongly non-linear codes. \n",
+    "\n",
+    "## Operator transform\n",
+    "The actual transform of Fermion operators into qubit operators is done with the routine $\\text{binary_code_transform}$, that takes a Hamiltonian and a suitable code as inputs, outputting a qubit Hamiltonian.   \n",
+    "Let us consider the case of a molecule with 4 modes where, due to the absence of magnetic interactions, the set of valid modes is only $$ \\mathcal{V}=\\lbrace (1,\\, 1,\\, 0,\\, 0 ),\\,(1,\\, 0,\\, 0,\\, 1 ),\\,(0,\\, 1,\\, 1,\\, 0 ),\\,(0,\\, 0,\\, 1,\\, 1 )\\rbrace \\, .$$\n",
+    "One can either use an (even weight) checksum code to save a single qubit, or use and (odd weight) checksum code on spin-up and -down modes each to save two qubits. Since the ordering is even-odd, however, this requires to concatenate the with the interleaved code, which switches the spin indexing of the qubits from even-odd ordering to up-then-down. Instead of using the interleaved code, we can also use the reorder function to apply up-then-down ordering on the hamiltonian."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fermionic Hamiltonian\n",
+      "0.00549750443158 [3^ 2^ 2 1] +\n",
+      "-0.0117319857638 [1^ 0^ 3 2] +\n",
+      "-0.0461456528031 [2^ 1^ 1 0] +\n",
+      "-0.339184381747 [3^ 2^ 3 2] +\n",
+      "-0.795272686478 [1^ 1] +\n",
+      "-0.228253768937 [3^ 0^ 3 0] +\n",
+      "-0.365492570268 [2^ 2] +\n",
+      "0.0117319857638 [2^ 1^ 3 0] +\n",
+      "-0.497790805326 [1^ 0^ 1 0] +\n",
+      "-0.216521783173 [2^ 0^ 2 0] +\n",
+      "0.046145634732 [2^ 0] +\n",
+      "0.0117319857638 [3^ 0^ 2 1] +\n",
+      "-0.795272686478 [0^ 0] +\n",
+      "0.00549750443158 [2^ 1^ 3 2] +\n",
+      "-0.216521783173 [3^ 1^ 3 1] +\n",
+      "0.046145634732 [1^ 3] +\n",
+      "0.0461456528031 [3^ 0^ 1 0] +\n",
+      "-0.365492570268 [3^ 3] +\n",
+      "-0.228253768937 [2^ 1^ 2 1] +\n",
+      "-0.0117319857638 [3^ 2^ 1 0] +\n",
+      "0.0461456528031 [1^ 0^ 3 0] +\n",
+      "-0.00549750443158 [3^ 2^ 3 0] +\n",
+      "0.046145634732 [0^ 2] +\n",
+      "0.046145634732 [3^ 1] +\n",
+      "-6.76981321809 [] +\n",
+      "-0.00549750443158 [3^ 0^ 3 2] +\n",
+      "-0.0461456528031 [1^ 0^ 2 1]\n",
+      "The eigenspectrum\n",
+      "[-7.86277316 -7.78339621 -7.78339621 -7.71405669 -7.71405669 -7.71405669\n",
+      " -7.70047584 -7.56998474 -7.56998474 -7.51199971 -7.51199971 -7.36481744\n",
+      " -7.15152548 -7.13040696 -7.13040696 -6.76981322]\n",
+      "\n",
+      "-----\n",
+      "\n",
+      "Jordan-Wigner transformed Hamiltonian\n",
+      "0.0129107802731 [X1 Z2 X3] +\n",
+      "0.0115364132008 [Z0 X1 Z2 X3] +\n",
+      "-0.0132436983303 [Z2] +\n",
+      "0.0115364132008 [X0 X2] +\n",
+      "0.0115364132008 [Z0 Y1 Z2 Y3] +\n",
+      "0.124447701331 [Z0 Z1] +\n",
+      "-0.0013743761079 [Y1 Y3] +\n",
+      "-0.0013743761079 [X0 Z1 X2 Z3] +\n",
+      "-0.00293299644095 [X0 X1 Y2 Y3] +\n",
+      "0.16199475388 [Z0] +\n",
+      "0.0541304457933 [Z1 Z3] +\n",
+      "0.16199475388 [Z1] +\n",
+      "0.0129107802731 [X0 Z1 X2] +\n",
+      "-0.0013743761079 [Y0 Z1 Y2 Z3] +\n",
+      "0.0129107802731 [Y0 Z1 Y2] +\n",
+      "0.0541304457933 [Z0 Z2] +\n",
+      "0.0847960954367 [Z2 Z3] +\n",
+      "0.00293299644095 [Y0 X1 X2 Y3] +\n",
+      "-0.0132436983303 [Z3] +\n",
+      "0.0570634422342 [Z1 Z2] +\n",
+      "0.0129107802731 [Y1 Z2 Y3] +\n",
+      "0.0115364132008 [Y0 Y2] +\n",
+      "0.0570634422342 [Z0 Z3] +\n",
+      "-0.00293299644095 [Y0 Y1 X2 X3] +\n",
+      "-7.49894690201 [] +\n",
+      "-0.0013743761079 [X1 X3] +\n",
+      "0.00293299644095 [X0 Y1 Y2 X3]\n",
+      "the eigenspectrum of the transformed hamiltonian\n",
+      "[-7.86277316 -7.78339621 -7.78339621 -7.71405669 -7.71405669 -7.71405669\n",
+      " -7.70047584 -7.56998474 -7.56998474 -7.51199971 -7.51199971 -7.36481744\n",
+      " -7.15152548 -7.13040696 -7.13040696 -6.76981322]\n",
+      "\n",
+      "-----\n",
+      "\n",
+      "Even-weight checksum code\n",
+      "-0.0129107802731 [Z0 X1] +\n",
+      "0.0129107802731 [Y0 Z1 Y2] +\n",
+      "0.108260891587 [Z0 Z2] +\n",
+      "-0.0132436983303 [Z2] +\n",
+      "0.114126884468 [Z1 Z2] +\n",
+      "0.0129107893087 [X0 X2] +\n",
+      "-0.0132436983303 [Z0 Z1 Z2] +\n",
+      "-0.0058659928819 [Y0 Y1 X2] +\n",
+      "0.209243796768 [Z0 Z1] +\n",
+      "-0.0129107893087 [X1] +\n",
+      "-7.49894690201 [] +\n",
+      "0.16199475388 [Z1] +\n",
+      "0.0129107802731 [X0 Z1 X2] +\n",
+      "0.16199475388 [Z0] +\n",
+      "0.0129107802731 [X1 Z2] +\n",
+      "0.0129107893087 [Y0 Y2] +\n",
+      "0.0129107893087 [Z0 X1 Z2] +\n",
+      "0.0058659928819 [X0 Y1 Y2]\n",
+      "the eigenspectrum of the transformed hamiltonian\n",
+      "[-7.86277316 -7.71405669 -7.71405669 -7.71405669 -7.70047584 -7.36481744\n",
+      " -7.15152548 -6.76981322]\n",
+      "\n",
+      "-----\n",
+      "\n",
+      "Double odd-weight checksum codes\n",
+      "0.17523845221 [Z0] +\n",
+      "-0.0117319857638 [Y0 Y1] +\n",
+      "0.0258215786173 [X0] +\n",
+      "0.0951169122996 [Z0 Z1] +\n",
+      "-0.0258215786173 [X1] +\n",
+      "-7.6072077936 [] +\n",
+      "0.17523845221 [Z1] +\n",
+      "-0.0258215605462 [Z0 X1] +\n",
+      "0.0258215605462 [X0 Z1]\n",
+      "the eigenspectrum of the transformed hamiltonian\n",
+      "[-7.86277316 -7.71405669 -7.70047584 -7.15152548]\n",
+      "\n",
+      "-----\n",
+      "\n",
+      "Instead of interleaving, we can apply up-then-down ordering using the reorder function:\n",
+      "0.17523845221 [Z0] +\n",
+      "0.0258215786173 [X0 Z1] +\n",
+      "0.0258215605462 [X0] +\n",
+      "0.0951169122996 [Z0 Z1] +\n",
+      "0.0258215605462 [X1] +\n",
+      "-7.6072077936 [] +\n",
+      "0.17523845221 [Z1] +\n",
+      "0.0258215786173 [Z0 X1] +\n",
+      "0.0117319857638 [X0 X1]\n",
+      "the eigenspectrum of the transformed hamiltonian\n",
+      "[-7.86277316 -7.71405669 -7.70047584 -7.15152548]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openfermion.transforms import *\n",
+    "from openfermion.hamiltonians import MolecularData\n",
+    "from openfermion.transforms import binary_code_transform\n",
+    "from openfermion.transforms import get_fermion_operator\n",
+    "from openfermion.utils import eigenspectrum, up_then_down, reorder\n",
+    "from openfermion.ops import normal_ordered\n",
+    "\n",
+    "def LiH_hamiltonian():\n",
+    "    geometry = [('Li', (0., 0., 0.)), ('H', (0., 0., 1.45))]\n",
+    "    molecule = MolecularData(geometry, 'sto-3g', 1,\n",
+    "                             description=\"1.45\")\n",
+    "    molecule.load()\n",
+    "    molecular_hamiltonian = molecule.get_molecular_hamiltonian(occupied_indices = [0], active_indices = [1,2])\n",
+    "    hamiltonian = normal_ordered(get_fermion_operator(molecular_hamiltonian))\n",
+    "    return hamiltonian\n",
+    "\n",
+    "hamiltonian = LiH_hamiltonian()\n",
+    "print('Fermionic Hamiltonian')\n",
+    "print (hamiltonian)\n",
+    "print(\"The eigenspectrum\")\n",
+    "print(eigenspectrum(hamiltonian))\n",
+    "\n",
+    "print('\\n-----\\n')\n",
+    "jw = binary_code_transform(hamiltonian, jordan_wigner_code(4))\n",
+    "print('Jordan-Wigner transformed Hamiltonian')\n",
+    "print(jw)\n",
+    "print(\"the eigenspectrum of the transformed hamiltonian\")\n",
+    "print(eigenspectrum(jw))\n",
+    "\n",
+    "print('\\n-----\\n')\n",
+    "cksm_save_one = binary_code_transform(hamiltonian, checksum_code(4,0))\n",
+    "print('Even-weight checksum code')\n",
+    "print(cksm_save_one)\n",
+    "print(\"the eigenspectrum of the transformed hamiltonian\")\n",
+    "print(eigenspectrum(cksm_save_one))\n",
+    "\n",
+    "print('\\n-----\\n')\n",
+    "up_down_save_two = binary_code_transform(hamiltonian, interleaved_code(4)*(2*checksum_code(2,1)))\n",
+    "print('Double odd-weight checksum codes')\n",
+    "print(up_down_save_two )\n",
+    "print(\"the eigenspectrum of the transformed hamiltonian\")\n",
+    "print(eigenspectrum(up_down_save_two ))\n",
+    "\n",
+    "print('\\n-----\\n')\n",
+    "print('Instead of interleaving, we can apply up-then-down ordering using the reorder function:')\n",
+    "up_down_save_two = binary_code_transform(reorder(hamiltonian,up_then_down), 2*checksum_code(2,1))\n",
+    "print(up_down_save_two)\n",
+    "print(\"the eigenspectrum of the transformed hamiltonian\")\n",
+    "print(eigenspectrum(up_down_save_two))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/src/openfermion/hamiltonians/_molecular_data.py b/src/openfermion/hamiltonians/_molecular_data.py
index 51db88ed1..2af97e56f 100644
--- a/src/openfermion/hamiltonians/_molecular_data.py
+++ b/src/openfermion/hamiltonians/_molecular_data.py
@@ -820,7 +820,7 @@ def get_active_space_integrals(self,
                                              active_indices,
                                              active_indices)])
 
-    def get_molecular_hamiltonian(self,occupied_indices=None,
+    def get_molecular_hamiltonian(self, occupied_indices=None,
                                   active_indices=None):
         """Output arrays of the second quantized Hamiltonian coefficients.
 
@@ -829,7 +829,7 @@ def get_molecular_hamiltonian(self,occupied_indices=None,
                 indicating which orbitals should be considered doubly occupied.
             active_indices(list): A list of spatial orbital indices indicating
                 which orbitals should be considered active.
-                
+
         Returns:
             molecular_hamiltonian: An instance of the MolecularOperator class.
         """
@@ -851,7 +851,7 @@ def get_molecular_hamiltonian(self,occupied_indices=None,
         # Loop through integrals.
         for p in range(n_qubits // 2):
             for q in range(n_qubits // 2):
-        
+
                 # Populate 1-body coefficients. Require p and q have same spin.
                 one_body_coefficients[2 * p, 2 * q] = one_body_integrals[
                     p, q]
diff --git a/src/openfermion/ops/_symbolic_binary.py b/src/openfermion/ops/_symbolic_binary.py
index 9c85f1441..8582ba605 100644
--- a/src/openfermion/ops/_symbolic_binary.py
+++ b/src/openfermion/ops/_symbolic_binary.py
@@ -93,7 +93,7 @@ def __init__(self, term=None):
 
         # Sequence input: list of tuples of tuples
         elif isinstance(term, tuple) or isinstance(term, list):
-            self._parse_sequence(term)
+            self._parse_sequence(list(term))
 
         # String input
         elif isinstance(term, str):
diff --git a/src/openfermion/tests/_example_test.py b/src/openfermion/tests/_example_test.py
index 3af9c64e6..f8d859041 100644
--- a/src/openfermion/tests/_example_test.py
+++ b/src/openfermion/tests/_example_test.py
@@ -28,6 +28,7 @@ def setUp(self):
         string_length = len(THIS_DIRECTORY)
         self.directory = THIS_DIRECTORY[:(string_length - 15)] + 'examples/'
         self.demo_name = 'openfermion_demo.ipynb'
+        self.binary_code_transforms_demo = 'binary_code_transforms_demo.ipynb'
         self.givens_rotations_demo_name = 'givens_rotations.ipynb'
 
     def test_demo(self):
@@ -61,6 +62,37 @@ def test_demo(self):
             errors = []
         self.assertEqual(errors, [])
 
+    def test_binary_code_transforms_demo(self):
+        # Determine if python 2 or 3 is being used.
+        major_version, minor_version = sys.version_info[:2]
+        if major_version == 2 or minor_version == 6:
+            version = str(major_version)
+
+            # Run ipython notebook via nbconvert and collect output.
+            with tempfile.NamedTemporaryFile(suffix='.ipynb') as output_file:
+                args = ['jupyter',
+                        'nbconvert',
+                        '--to',
+                        'notebook',
+                        '--execute',
+                        '--ExecutePreprocessor.timeout=600',
+                        '--ExecutePreprocessor.kernel_name=python{}'.format(
+                            version),
+                        '--output',
+                        output_file.name,
+                        self.directory + self.binary_code_transforms_demo]
+                subprocess.check_call(args)
+                output_file.seek(0)
+                nb = nbformat.read(output_file, nbformat.current_nbformat)
+
+            # Parse output and make sure there are no errors.
+            errors = [output for cell in nb.cells if "outputs" in cell for
+                      output in cell["outputs"] if
+                      output.output_type == "error"]
+        else:
+            errors = []
+        self.assertEqual(errors, [])
+
     def test_performance_benchmarks(self):
 
         # Import performance benchmarks and seed random number generator.
diff --git a/src/openfermion/transforms/__init__.py b/src/openfermion/transforms/__init__.py
index 3c451549c..ef4da5c62 100644
--- a/src/openfermion/transforms/__init__.py
+++ b/src/openfermion/transforms/__init__.py
@@ -16,6 +16,14 @@
 from ._bravyi_kitaev import bravyi_kitaev
 from ._binary_code_transform import (binary_code_transform,
                                      dissolve)
+from ._code_transform_functions import (bravyi_kitaev_code,
+                                        checksum_code,
+                                        interleaved_code,
+                                        jordan_wigner_code,
+                                        parity_code,
+                                        weight_two_segment_code,
+                                        weight_one_binary_addressing_code,
+                                        weight_one_segment_code)
 from ._conversion import (get_fermion_operator,
                           get_interaction_rdm,
                           get_interaction_operator,
diff --git a/src/openfermion/transforms/_bravyi_kitaev.py b/src/openfermion/transforms/_bravyi_kitaev.py
index 2dacc68b0..dd4a3d122 100644
--- a/src/openfermion/transforms/_bravyi_kitaev.py
+++ b/src/openfermion/transforms/_bravyi_kitaev.py
@@ -19,6 +19,7 @@
 
 def bravyi_kitaev(operator, n_qubits=None):
     """Apply the Bravyi-Kitaev transform and return qubit operator.
+    (arxiv1701.07072)
 
     Args:
         operator (openfermion.ops.FermionOperator):
diff --git a/src/openfermion/transforms/_code_transform_functions.py b/src/openfermion/transforms/_code_transform_functions.py
new file mode 100644
index 000000000..e0a5c0f42
--- /dev/null
+++ b/src/openfermion/transforms/_code_transform_functions.py
@@ -0,0 +1,258 @@
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+""" Pre-existing codes for Fermion-qubit mappings
+    based on (arXiv:1712.07067) """
+
+import numpy
+
+from openfermion.ops import BinaryCode, SymbolicBinary, linearize_decoder
+
+
+def _encoder_bk(n_modes):
+    """  Helper function for bravyi_kitaev_code that outputs the binary-tree
+    (dimension x dimension)-matrix used for the encoder in the
+    Bravyi-Kitaev transform.
+
+    Args:
+        n_modes (int): length of the matrix, the dimension x dimension
+
+    Returns (numpy.ndarray): encoder matrix
+    """
+    reps = int(numpy.ceil(numpy.log2(n_modes)))
+    mtx = numpy.array([[1, 0], [1, 1]])
+    for repetition in numpy.arange(1, reps + 1):
+        mtx = numpy.kron(numpy.eye(2, dtype=int), mtx)
+        for column in numpy.arange(0, 2 ** repetition):
+            mtx[2 ** (repetition + 1) - 1, column] = 1
+    return mtx[0:n_modes, 0:n_modes]
+
+
+def _decoder_bk(n_modes):
+    """ Helper function for bravyi_kitaev_code that outputs the inverse of the
+    binary tree matrix utilized for decoder in the Bravyi-Kitaev transform.
+
+    Args:
+        n_modes (int): size of the matrix is modes x modes
+
+    Returns (numpy.ndarray): decoder matrix
+    """
+    reps = int(numpy.ceil(numpy.log2(n_modes)))
+    mtx = numpy.array([[1, 0], [1, 1]])
+    for repetition in numpy.arange(1, reps + 1):
+        mtx = numpy.kron(numpy.eye(2, dtype=int), mtx)
+        mtx[2 ** (repetition + 1) - 1, 2 ** repetition - 1] = 1
+    return mtx[0:n_modes, 0:n_modes]
+
+
+def _encoder_checksum(modes):
+    """ Helper function for checksum_code that outputs the encoder matrix.
+
+    Args:
+        modes (int):  matrix size is (modes - 1) x modes
+
+    Returns (numpy.ndarray): encoder matrix
+    """
+    enc = numpy.zeros(shape=(modes - 1, modes), dtype=int)
+    for i in range(modes - 1):
+        enc[i, i] = 1
+    return enc
+
+
+def _decoder_checksum(modes, odd):
+    """ Helper function for checksum_code that outputs the decoder.
+
+    Args:
+        modes (int):  number of modes
+        odd (int or bool): 1 (True) or 0 (False), if odd,
+            we encode all states with odd Hamming weight
+
+    Returns (list): list of SymbolicBinary
+    """
+    if odd:
+        all_in = SymbolicBinary('1')
+    else:
+        all_in = SymbolicBinary()
+
+    for mode in range(modes - 1):
+        all_in += SymbolicBinary('w' + str(mode))
+
+    djw = linearize_decoder(numpy.identity(modes - 1, dtype=int))
+    djw.append(all_in)
+    return djw
+
+
+def _binary_address(digits, address):
+    """ Helper function to fill in an encoder column/decoder component of a
+    certain number.
+
+    Args:
+        digits (int): number of digits, which is the qubit number
+        address (int): column index, decoder component
+
+    Returns (tuple): encoder column, decoder component
+    """
+    binary_expression = SymbolicBinary('1')
+
+    # isolate the binary number and fill up the mismatching digits
+    address = bin(address)[2:]
+    address = ('0' * (digits - len(address))) + address
+    for index in numpy.arange(digits):
+        binary_expression *= SymbolicBinary(
+            'w' + str(index) + ' + 1 + ' + address[index])
+
+    return list(map(int, list(address))), binary_expression
+
+
+def checksum_code(n_modes, odd):
+    """ Checksum code for either even or odd Hamming weight. The Hamming weight
+    is defined such that it yields the total occupation number for a given basis
+    state. A Checksum code with odd weight will encode all states with odd
+    occupation number. This code saves one qubit: n_qubits = n_modes - 1.
+        
+    Args:
+        n_modes (int): number of modes
+        odd (int or bool): 1 (True) or 0 (False), if odd,
+            we encode all states with odd Hamming weight
+
+    Returns (BinaryCode): The checksum BinaryCode
+    """
+    return BinaryCode(_encoder_checksum(n_modes),
+                      _decoder_checksum(n_modes, odd))
+
+
+def jordan_wigner_code(n_modes):
+    """ The Jordan-Wigner transform as binary code.
+        
+    Args:
+        n_modes (int): number of modes
+
+    Returns (BinaryCode): The Jordan-Wigner BinaryCode
+    """
+    return BinaryCode(numpy.identity(n_modes, dtype=int), linearize_decoder(
+        numpy.identity(n_modes, dtype=int)))
+
+
+def bravyi_kitaev_code(n_modes):
+    """ The Bravyi-Kitaev transform as binary code. The implementation
+    follows arXiv:1208.5986.
+        
+    Args:
+        n_modes (int): number of modes
+
+    Returns (BinaryCode): The Bravyi-Kitaev BinaryCode
+    """
+    return BinaryCode(_encoder_bk(n_modes),
+                      linearize_decoder(_decoder_bk(n_modes)))
+
+
+def parity_code(n_modes):
+    """ The parity transform (arXiv:1208.5986) as binary code. This code is
+    very similar to the Jordan-Wigner transform, but with long update strings
+    instead of parity strings. It does not save qubits: n_qubits = n_modes.
+        
+    Args:
+        n_modes (int): number of modes
+
+    Returns (BinaryCode): The parity transform BinaryCode
+    """
+    dec_mtx = numpy.reshape(([1] + [0] * (n_modes - 1)) +
+                            ([1, 1] + (n_modes - 1) * [0]) * (n_modes - 2) +
+                            [1, 1], (n_modes, n_modes))
+    enc_mtx = numpy.tril(numpy.ones((n_modes, n_modes), dtype=int))
+
+    return BinaryCode(enc_mtx, linearize_decoder(dec_mtx))
+
+
+def weight_one_binary_addressing_code(exponent):
+    """ Weight-1 binary addressing code (arXiv:1712.07067). This highly
+    non-linear code works for a number of modes that is an integer power
+    of two. It encodes all possible vectors with Hamming weight 1, which
+    corresponds to all states with total occupation one. The amount of
+    qubits saved here is maximal: for a given argument 'exponent', we find
+    n_modes = 2 ^ exponent, n_qubits = exponent. 
+
+    Note:
+        This code is highly non-linear and might produce a lot of terms.
+
+    Args:
+        exponent (int): exponent for the number of modes n_modes = 2 ^ exponent
+
+    Returns (BinaryCode): the weight one binary addressing BinaryCode
+    """
+    encoder = numpy.zeros((exponent, 2 ** exponent), dtype=int)
+    decoder = [0] * (2 ** exponent)
+    for counter in numpy.arange(2 ** exponent):
+        encoder[:, counter], decoder[counter] = \
+            _binary_address(exponent, counter)
+    return BinaryCode(encoder, decoder)
+
+
+def weight_one_segment_code():
+    """ Weight-1 segment code (arXiv:1712.07067). Outputs a 3-mode, 2-qubit
+    code, which encodes all the vectors (states) with Hamming weight
+    (occupation) 0 and 1. n_qubits = 2, n_modes = 3.
+    A linear amount of qubits can be saved  appending several instances of this
+    code.
+
+    Note:
+        This code is highly non-linear and might produce a lot of terms.
+
+    Returns (BinaryCode): weight one segment code
+    """
+    return BinaryCode([[1, 0, 1], [0, 1, 1]],
+                      ['w0 w1 + w0', 'w0 w1 + w1', ' w0 w1'])
+
+
+def weight_two_segment_code():
+    """ Weight-2 segment code (arXiv:1712.07067). Outputs a 5-mode, 4-qubit
+    code, which encodes all the vectors (states) with Hamming weight
+    (occupation) 2 and 1. n_qubits = 4, n_modes = 5.
+    A linear amount of qubits can be saved  appending several instances of this
+    code.
+
+    Note:
+        This code is highly non-linear and might produce a lot of terms.
+
+    Returns (BinaryCode): weight-2 segment code
+    """
+    switch = ('w0 w1 w2 + w0 w1 w3 + w0 w2 w3 + w1 w2 w3 + w0 w1 w2 +'
+              ' w0 w1 w2 w3')
+
+    return BinaryCode([[1, 0, 0, 0, 1], [0, 1, 0, 0, 1], [0, 0, 1, 0, 1],
+                       [0, 0, 0, 1, 1]], ['w0 + ' + switch, 'w1 + ' + switch,
+                                          'w2 + ' + switch, 'w3 + ' + switch,
+                                          switch])
+
+
+def interleaved_code(modes):
+    """ Linear code that reorders orbitals from even-odd to up-then-down.
+    In up-then-down convention, one can append two instances of the same
+    code 'c' in order to have two symmetric subcodes that are symmetric for 
+    spin-up and -down modes: ' c + c '.
+    In even-odd, one can concatenate with the interleaved_code 
+    to have the same result:' interleaved_code * (c + c)'.
+    This code changes the order of modes from (0, 1 , 2, ... , modes-1 )
+    to (0, modes/2, 1 modes/2+1, ... , modes-1, modes/2 - 1).  
+    n_qubits = n_modes. 
+    
+    Args: modes (int): number of modes, must be even 
+    
+    Returns (BinaryCode): code that interleaves orbitals
+    """
+    if modes % 2 == 1:
+        raise ValueError('number of modes must be even')
+    else:
+        mtx = numpy.zeros((modes, modes), dtype=int)
+        for index in numpy.arange(modes // 2, dtype=int):
+            mtx[index, 2 * index] = 1
+            mtx[modes // 2 + index, 2 * index + 1] = 1
+        return BinaryCode(mtx, linearize_decoder(mtx.transpose()))
diff --git a/src/openfermion/transforms/_code_transform_functions_test.py b/src/openfermion/transforms/_code_transform_functions_test.py
new file mode 100644
index 000000000..fbe0a3926
--- /dev/null
+++ b/src/openfermion/transforms/_code_transform_functions_test.py
@@ -0,0 +1,100 @@
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+import unittest
+
+from openfermion.transforms._code_transform_functions import *
+from openfermion.hamiltonians import MolecularData
+from openfermion.transforms import binary_code_transform
+from openfermion.transforms import get_fermion_operator
+from openfermion.utils import eigenspectrum
+from openfermion.transforms import jordan_wigner,bravyi_kitaev
+
+
+def lih_hamiltonian():
+    geometry = [('Li', (0., 0., 0.)), ('H', (0., 0., 1.45))]
+    active_space_start = 1
+    active_space_stop = 3
+    molecule = MolecularData(geometry, 'sto-3g', 1,
+                             description="1.45")
+    molecule.load()
+    molecular_hamiltonian = molecule.get_molecular_hamiltonian(
+        occupied_indices=range(active_space_start),
+        active_indices=range(active_space_start, active_space_stop))
+    hamiltonian = get_fermion_operator(molecular_hamiltonian)
+    ground_state_energy = eigenspectrum(hamiltonian)[0]
+    return hamiltonian, ground_state_energy
+
+
+class CodeTransformTest(unittest.TestCase):
+    def test_checksum_code(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = checksum_code(4, 0)
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+
+    def test_jordan_wigner(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = jordan_wigner_code(4)
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+        self.assertDictEqual(qubit_hamiltonian.terms,
+                               jordan_wigner(hamiltonian).terms)
+
+    def test_bravyi_kitaev(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = bravyi_kitaev_code(4)
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+        qubit_spectrum = eigenspectrum(qubit_hamiltonian)
+        fenwick_spectrum = eigenspectrum(bravyi_kitaev(hamiltonian))
+        for eigen_idx, eigenvalue in enumerate(qubit_spectrum):
+            self.assertAlmostEqual(eigenvalue,fenwick_spectrum[eigen_idx])
+
+    def test_parity_code(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = parity_code(4)
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+
+    def test_weight_one_binary_addressing_code(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = interleaved_code(8) * (
+                2 * weight_one_binary_addressing_code(2))
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+
+    def test_weight_one_segment_code(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = interleaved_code(6) * (2 * weight_one_segment_code())
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+
+    def test_weight_two_segment_code(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = weight_two_segment_code()
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])
+
+    def test_interleaved_code(self):
+        hamiltonian, gs_energy = lih_hamiltonian()
+        code = interleaved_code(4)
+        qubit_hamiltonian = binary_code_transform(hamiltonian, code)
+        self.assertAlmostEqual(gs_energy,
+                               eigenspectrum(qubit_hamiltonian)[0])