Error message on my machine (Ubuntu 16, Python 2.7.12):

======================================================================
ERROR: test_separate_state (__main__.TestMultiQuantumRegisterStates)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "QuantumComputer.py", line 1614, in test_separate_state
    self.assertTrue(np.allclose(value_state,target_state))
  File "/home/lucas/.local/lib/python2.7/site-packages/numpy/core/numeric.py", line 2478, in allclose
    res = all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))
  File "/home/lucas/.local/lib/python2.7/site-packages/numpy/core/numeric.py", line 2560, in isclose
    return within_tol(x, y, atol, rtol)
  File "/home/lucas/.local/lib/python2.7/site-packages/numpy/core/numeric.py", line 2543, in within_tol
    result = less_equal(abs(x-y), atol + rtol * abs(y))
TypeError: __array_prepare__ must return an ndarray or subclass thereof which is otherwise identical to its input

----------------------------------------------------------------------
Ran 45 tests in 6.081s

FAILED (errors=1)

pip list:

lucas@qed:~/Projects/QuantumComputing$ pip list
adium-theme-ubuntu (0.3.4)
Cython (0.23.4)
numpy (1.12.0)
pip (8.1.1)
Reindent (0.1.1)
setuptools (20.7.0)
unity-lens-photos (1.0)
wheel (0.29.0)

Full output of the command python2 QuantumComputer.py:
output.txt

The code is written for Python 2.7, and will not compile without a lot of changes in 3.4+
Has anyone created a version that runs on 3.4 or 3.5 ?

README.md says (example "Pure python quantum computing machinery"):

qc.measure("q1")
qc.measure("q2")
Probability.pretty_print_probabilities(qc.qubits.get_quantum_register_containing("q1").get_state())

If you do so, the last line always output:

|psi>=|00>
Pr(|00>)=1.000000; 
<state>=1.000000

Because measurement destroyed the state. IMHO, it should be get_noop instead of get_state.

I can run it even in Pythonista. But given the large size of the program, it will be better if one can have separate files to run it. So far not successful and have to run my qm as test by cloning one of the test as source. And sometimes it does not work. I will give example whilst I continue he struggle. Js has an drag and drop n ipad. Hope python has one with Pythonista even if just text.

Examples in README fail due to a missing get_qubit_named method

Minor: On the section about "Working with Individual States and gates", one minor issue is that the qc has to be either "qc.reset()" or redefine "qc = ...". I suspect the other issue can be handled.

Major: try to reproduce the circuit of teleport from quirk to composer. It can be done on the IBM openqasm 2.0 composer but not here. The issue is that there is no cz operator. I suspect one can amend these lines but not sure I am expert enough to try.

                ...
		cnot_re=re.compile('^cx (q\[[0-4]\]), (q\[[0-4]\])$')      # <-- need to change to (x|y|z)
		for l in lines:
			l=l.strip()
			if not l: continue
			# CNOT operates on two qubits so gets special processing
			cnot=cnot_re.match(l)
			if cnot:
				control_qubit=cnot.group(1)  #<-- group(2)
				target_qubit=cnot.group(2)   #<-- group(3)
                                # depends upon group(1) and feed group(1) into the function
				l='self.apply_two_qubit_gate_CNOT(%s,%s'%(control_qubit,target_qubit) #<-- major change needed
			for k,v in translation:
				l=l.replace(k,v)
			l=l+')'
			# Now running the code
			exec(l,globals(),locals())
                        ...

Somehow the cx in the first line need to increase to cover cy and cz and then apply the appropriate logic to it (the line l="..." for the "translation".

The regular expression might be easily fixed by changing into something like

cnot_re=re.compile('^c(x|y|z} (q\[[0-4]\]), (q\[[0-4]\])$')

and some change in logic of the "if cnot" so to use group 2 and 3 not 1 and 2 and use group 1 to handle cx/cy/cz

But the logic under self.apply_two_qubit_gate_CNOT is not that easy as it involved different way to handle cx/cy/cz gate change.

Dear Dr. Christine,

I am following up on my research in the philosophical field of "quantum thinking" (not binary... false/true, good/evil, right/wrong ...) and, meanwhile, I try to deepen my technical knowledge on the functioning of the QASM language .

I'm new to Python3, just a month old, but I'm old in several other languages, including C++.
Unfortunately I still do not fully understand the functioning of your application, so I apologize for taking your time.

Despite the online availability of the IBM Quantum-e platform, it naturally needs an internet connection and ends up being slow for many tests, as well as the limitations on the size of the QASM code, and the track restrictions available for CNOT gates.

For the huge amount of logical testing I need to do, your application is 100% effective. It is fast and flexible, precisely because it is not limited to the constraints of the real quantum computer.

Well ... after this long introduction, I explain below the reason for my post:

Are the qubits in |psi>=|100> from Probability.pretty_print_probabilities function in "reverse" order 01234 ?

I was testing the Toffoli gate, and I expected the following results in 43210 order:
00 --> |psi>=|000>
01 --> |psi>=|001>
10 --> |psi>=|010>
11 --> |psi>=|111>

But, I always get the following result:
00 --> |psi>=|000>
01 --> |psi>=|100> <-------Look at this! In reverse order 01234 !
10 --> |psi>=|010>
11 --> |psi>=|111>

I thought I had typed something wrong in the qasm code, but I realized that the sequence is in reverse order 01234.

Can we modify this?

p.s
Later I extended the qasm code to do more tests, adding the result of q2 with q3 and putting the final result in q4.
I initialized only q0 and q3 with 1 to actually do nothing, and I got the following print:
|psi>|10010> in 01234 order...

Many thanks,

Marcus Mello
UNIRIO
Universidade Federal do Estado do Rio de Janeiro
Departamento de Filosofia

=====================================

from QuantumComputer import *

qasm="""

#Toffoli - q0+q1=q2 +q3=q4;

#entries;

#q0;
x q[0];

#q1;
#x q[1];

#q3;
x q[3];

#first step: q0+q1=q2;

id q[2];
h q[2];
cx q[1], q[2];
tdg q[2];
cx q[0], q[2];
tdg q[2];
cx q[1], q[2];
tdg q[2];
cx q[0], q[2];
tdg q[1];
tdg q[2];
h q[2];

#ibm flip;
cx q[1], q[2];
h q[1];
h q[2];
cx q[1], q[2];
h q[1];
h q[2];
cx q[1], q[2];

cx q[0], q[2];
tdg q[2];
tdg q[0];
cx q[0], q[2];

#my flip;

cx q[1], q[2];
h q[1];
h q[2];
cx q[1], q[2];
h q[1];
h q[2];
cx q[1], q[2];

#next step: q2+q3=4;

id q[4];
h q[4];
cx q[3], q[4];
tdg q[4];
cx q[2], q[4];
tdg q[4];
cx q[3], q[4];
tdg q[4];
cx q[2], q[4];
tdg q[3];
tdg q[4];
h q[4];

#ibm flip;
cx q[3], q[4];
h q[3];
h q[4];
cx q[3], q[4];
h q[3];
h q[4];
cx q[3], q[4];

cx q[2], q[4];
tdg q[4];
tdg q[2];
cx q[2], q[4];

#my flip;
cx q[3], q[4];
h q[3];
h q[4];
cx q[3], q[4];
h q[3];
h q[4];
cx q[3], q[4];

measure q[0];
measure q[1];
measure q[2];
measure q[3];
measure q[4];

"""

qc=QuantumComputer()
qc.reset()
qc.execute(qasm)

print ()
print ("========== QUANTUM REGISTER ==========")

for n in range (0,5):
arg="q" + str(n)
print ("QUBIT",str(n))
Probability.pretty_print_probabilities (qc.qubits.get_quantum_register_containing(arg).get_state())

Hi! Do I need a quantum computer to run this sample?

Regards,
Nathan Aw
https://sg.linkedin.com/in/awnathan
http://www.nasdaq.com/article/guest-post-understanding-the-limits-and-potential-of-blockchain-technology-cm874892
https://www.hyperledger.org/blog/2017/12/05/developer-showcase-series-nathan-aw-ntt-data
https://bitcoinmagazine.com/authors/nathan-aw/
https://github.com/nathanawmk

Hello Dr. Christine, and here we are go... :)

Following the tests suggested in the Full User Guide from IBM (https://quantumexperience.ng.bluemix.net/qstage/#/user-guide), I'm in Section IV, Quantum Algorithms, specifically in Phase estimation algorithm.

The "Example circuit" demonstrates quantum phase estimation, setting qubit Q2 as target and qubit Q3 as a pointer.

This is the result from IBM Simulator:

The result expected is |01000> (in 43210 order) or |00010> (in 01234 order) where the pointer qubit Q3 has always the value |1> that must refer to phase -1 of target qubit Q2.

But, this same test executed under the QuantumComputer.py, results from different way:

The used source code below has a Toffoli sample just to demonstrate the position of qubit Q4, that it actually is in order 01234.

Phase.txt

I commented the "measure" to let me see the bloch values:

And the result is this:

Now, the weird thing...

Phase is working if Pointer qubit is LESS THAN Target qubit ! . . . . . . . ( 01234 order )

This source code sample do four subsequent phase gates and works well, since I use the pattern POINTER < TARGET...

Phase_Pointer gt Target.txt

Well ... this issue is very away from my math knowledge, or Python, or about the construction of QuantumComputer.py... :(

I hope you, the Mrs. Matrix Architect :) , have some insight about how to address this and can match the results to those that IBM Simulator has.

Best Regards.

Marcus Mello
UNIRIO
Universidade Federal do Estado do Rio de Janeiro
Departamento de Filosofia

Actually in the last weeks I have spent many (almost all) of my free hours testing and trying to understand how QuantumComputer.py works, even to try to help in some way.

Maybe someone might ask, "But why? This app is just an experiment! ".

Exactly! Precisely for this reason, because it was designed and developed to study quantum logic.

QuantumComputer.py is a laboratory, and things do not always (almost never) go exactly as we planned in the lab experiments. In addition to the reasons for studying and researching, there is another: I love the idea of having a quantum computer in my pocket! :)

QuantumComputer.py is a complex and robust application, encoded in a just single file!
You can send it attached in a whatsapp message! Even though most people have no interest in it, or even understand what it is ... :)

But this study of Dr. Christine has the potential to be easily distributed, shared by students around the world, making quantum computing as popular in this early 21st century as the Abacus was 4,000 years ago.

Anyway, I have plenty of reasons to spend my free hours on this project. :)

Now, I found a weird result from a banal test.
May be this could be useful to solve some logic constraints of CNOT.

Follows the test done in the IBM Quantum Simulator:
Note that Q0 set to |1> with X gate.

The QASM code:

And the result from IBM Quantum Simulator:

IBM show it in binary order 43210 as “00001” (or “001”)
In reverse (natural) order 01234, the result will must be “10000” (or “100”)

But the QuantumComputer.py result is different... "010"

This is the Python source code used in all tests:
CNOT Situation.txt

See the screen of source code used:

When the Q1 is set to |1>

IBM show it in binary order 43210 as “00010” (or “010”)
In reverse (natural) order 01234, the result will must be “01000” (or “010”)

But the QuantumComputer.py result is different... "100"

When the Q2 is set to |1>

IBM show it in binary order 43210 as “00111” (or “111”)
In reverse (natural) order 01234, the result will must be “11100” (or “111”)

In this test QuantumComputer.py result is EQUAL to IBM ! "111"

I hope these test cases can shed some light on the CNOT algorithm.