Homework 3

1. (25 points) Slide 35 indicates how to build a more complex gate from a sequence of simpler ones, i.e., how to build a CNOT from 2 Hadamards and a CPHASE, also depicted in slide 37. Use Quirk to create such a 3-gate 2-Qubit CNOT solution. Notice that CPHASE is a Pauli gate, you have to figure out which one. Also add a regular CNOT gate using 2 more Qubits. And add a sample display to all four Qubits. Then test your solution: The upper 2-Qubit circuit should behave the same as the lower 2-Qubit one for all four input combinations.

   Turn in file cphase.txt (export as URL)

2. (25 points) Test drive the IBM Quantum Experience and create a Toffoli equivalent circuit.
   Hints:
   • Sign up for an account (free).
   • Open the composer, choose some machine, e.g., ibmqx4 (5 qubits).
   • Create a Toffoli circuit from your solution of problem 6 in HW2.
   • Set both controls to 1 (using X gates).
   • Simulate a run, print out the result and capture the qasm code. Your output should be 111 on the 3 Qubits.
   • Run on the real machine. After you hit the run button, you will have to wait for an email (sevseral minutes in my case) reporting the outcome. Your output should be 111 on the 3 Qubits with a higher probability (0.572 for me). This is your first program running on a real quantum computer!!!

   Turn in file toffoli.pdf and toffoli.qasm

3. (25 points) Let's create the toffoli circuit in qiskit.
   Hints:
   • Install Quiskit, for me it's just: pip3 install quiskit
   • Follow the rest of the README to test your QASM program to create bell.py and run it: python3 bell.py
   • Copy bell.py into toffoli.py and change the program to create the toffoli circuit from the last exercise. You can either write it from scratch or use toffoli.qasm as a skelleton for it, and then expand it to the python API of Qiskit.
   • Notice: dagger gates are postfixed with dg, e.g., T-dagger is tdg().
   • Run it: python3 toffoli.py
   • Output: {'111': 1024}

   Turn in file toffoli.py

4. (25 points) You already created the 1-bit full adder from slide 41 on Quirk. The CCNOT gates are Toffoli gates, i.e., you can now create the adder in Qiskit.
   Hints:
   • Since you need 3 Toffoli gates, start with your prior Toffoli solution. You can either create a new method toffoli(), which is better from the software engineering point of view, or you put the toffoli gates into a loop and change the Qubit indexing to go though another indirection array, e.g., qr[t[i][x]], where i is the loop counter and x is the original 0/1/2 Qubit from your old solution.
   • Now initialize your indirection array such that the 1st, 2nd, 3rd Toffoli gates use the right Qubits. Think about this, it's not that hard once you get the idea.
   • And the 3 CNOT gates.
   • Put C gates on Q0 and Q2 (as 1 inputs).
   • Run it.
   • Output: {'10101': 1024}
   • Notice that we essentially built a Toffoli macro. You could also encapsulate it into a separate function/method to start programming with more complex circuits rather than basic gates, e.g., you could easily create a double adder from two single adders this way.

   Turn in file adder.py

5. We could even run it on IBM's larger-scale simulator (see device tab in Q Experience: ibmqx_quasm_simulator [20 Qbits] and ibmqx_hpc_quasm_simulator [32 Qubits, no conditions]), or connect Qiskit to a real IBM Q machine (but check their wiring, it's limited in that only certain Qubits are connected, which also dictates how you need to map your controlled gates.
   • I haven't tried this myself, but in IBM's quantum experience, click on your name->my account->advanced: generate API token->copy API token, to get a token for the IBM remote real machine and simulators above. With that, you can then change from the local to the remote simulator by changing your python code. The point here is that with many Qubits, your local machine is likely to be slow to simulate, yet IBM has two faster simulators in the cloud that you can use instead.
   • More details are found in the Qiskit documentation.
   • In addition, I suggest to download Qiskit and the correcsponding Jupyter notebook with the Qiskit tutorials, here are some rough notes:

     git clone https://github.com/QISKit/qiskit-sdk-py
     cd qiskit-sdk-py
     pip3 install -r --user requirements.txt
     cp Qconfig.py.default Qconfig.py
     #get API token from https://quantumexperience.ng.bluemix.net/qx/account/advanced
     #edit Qconfig.py: (leave hub/group/project at None)
     APItoken = '...'
     wget https://github.com/QISKit/qiskit-tutorial/archive/master.zip
     unzip master.zip
     cd qiskit-tutorial-master/
     jupyter notebook qiskit-tutorial-master/index.ipynb
     
     #https://github.com/QISKit/qiskit-sdk-py
     #create hello_quantum.py from 1st example
     python3 hello_quantum.py
     #try on IBM Q, edit program header to include Qconfig etc.
     ln -s qiskit-sdk-py/Qconfig.py .
     python3 hello_quantum.py
     

   • You could try to implement a small NP-hard/complete problem, e.g., traveling salesman with just a few cities, or something even simpler like map coloring. Think about that. We had a D-Wave example to give you some ideas, but it would look quite different on the IBM Q.