def test_delare():
quil = "DECLARE ro BITS"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Declare)
assert cmd.quil() == quil
quil = "DECLARE ro BITS [10]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Declare)
assert cmd.quil() == quil
quil = "DECLARE ro BITS [10] SHARING rs"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Declare)
assert cmd.quil() == quil
quil = "DECLARE ro BITS [10] SHARING rs OFFSET 2 this"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Declare)
assert cmd.quil() == quil
quil = "DECLARE ro BITS [10] SHARING rs OFFSET 16 REAL OFFSET 32 OCTET"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Declare)
assert cmd.quil() == quil
def test_pragma():
quil = "PRAGMA somename"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Pragma)
assert cmd.quil() == quil
quil = "PRAGMA somename arg0"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Pragma)
assert cmd.quil() == quil
quil = "PRAGMA somename arg0 arg1"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Pragma)
assert len(cmd.args) == 2
assert cmd.quil() == quil
quil = 'PRAGMA somename "some string"'
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Pragma)
assert not cmd.args
assert cmd.freeform == "some string"
assert cmd.quil() == quil
quil = 'PRAGMA somename arg2 arg3 arg7 "some string"'
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Pragma)
assert len(cmd.args) == 3
assert cmd.freeform == "some string"
assert cmd.quil() == quil
_test('PRAGMA gate_time H "10 ns"', qf.Pragma('gate_time', ['H'], '10 ns'))
_test('PRAGMA qubit 0', qf.Pragma('qubit', [0]))
_test('PRAGMA NO-NOISE', qf.Pragma('NO-NOISE'))
def test_comparisons():
quil = "EQ a[1] c[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.EQ)
assert cmd.quil() == quil
quil = "GT a[1] c[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.GT)
assert cmd.quil() == quil
quil = "GE a[1] c[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.GE)
assert cmd.quil() == quil
quil = "LT a[1] c[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.LT)
assert cmd.quil() == quil
quil = "LE a[1] c[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.LE)
assert cmd.quil() == quil
def test_defgate():
prog = qf.parse_quil(HADAMARD)
cmd = prog[0]
assert cmd.gatename == 'HADAMARD'
assert cmd.name == 'DEFGATE'
# assert cmd.matrix[0][0] == 1/math.sqrt(2) #FIXME
print(cmd)
prog = qf.parse_quil(I2)
cmd = prog[0]
assert cmd.gatename == 'I2'
assert cmd.name == 'DEFGATE'
assert cmd.matrix[2][2] == 1
assert str(cmd) == I2
def test_simple():
simple = "HALT", "WAIT", "NOP", "RESET"
for quil in simple:
prog = qf.parse_quil(quil)
assert len(prog) == 1
assert prog[0].quil() == quil
def test_measure():
quil = "MEASURE 1"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Measure)
assert cmd.quil() == quil
quil = "MEASURE 3 reg0[2]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Measure)
assert cmd.quil() == quil
prog = qf.parse_quil(quil)
print(len(prog))
print(prog)
_test("MEASURE 0", qf.Measure(0))
_test("MEASURE 0 b[1]", qf.Measure(0, qf.Register('b')[1]))
def test_gate_1qubit_param():
gates = 'RX', 'RY', 'RZ'
for g in gates:
quil = '{}(2.8) 42'.format(g)
cmd = qf.parse_quil(quil)[0]
assert cmd.gatename == g
assert cmd.qubits == [42]
assert cmd.params == [2.8]
def test_gate_2qubit():
gates = 'SWAP', 'CZ', 'CNOT', 'ISWAP'
for g in gates:
quil = '{} 2 42'.format(g)
cmd = qf.parse_quil(quil)[0]
assert cmd.gatename == g
assert cmd.qubits == [2, 42]
assert not cmd.params
def test_gate_1qubit():
gates = 'I', 'H', 'X', 'Y', 'Z', 'S', 'T', 'PHASE'
for g in gates:
quil = '{} 42'.format(g)
cmd = qf.parse_quil(quil)[0]
assert cmd.gatename == g
assert cmd.qubits == [42]
assert not cmd.params
def test_jump():
quil = "JUMP @some_target"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Jump)
assert cmd.target == "some_target"
assert cmd.quil() == quil
quil = "JUMP-UNLESS @some_target ro[2]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.JumpUnless)
# assert cmd.cbits == [('ro', 2)]
assert cmd.quil() == quil
quil = "JUMP-WHEN @some_target b[3]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.JumpWhen)
# assert cmd.cbits == [('b', 3)]
assert cmd.quil() == quil
def test_gate_2qubit_param():
gates = 'CPHASE00', 'CPHASE01', 'CPHASE10', 'CPHASE', 'PSWAP'
for g in gates:
quil = '{} 2 42'.format(g)
cmd = qf.parse_quil(quil)[0]
assert cmd.gatename == g
assert cmd.qubits == [2, 42]
assert not cmd.params
def test_gate_3qubit():
gates = 'CCNOT', 'CSWAP'
for g in gates:
quil = '{} 2 42 5'.format(g)
cmd = qf.parse_quil(quil)[0]
assert cmd.gatename == g
assert cmd.qubits == [2, 42, 5]
assert not cmd.params
def test_variable():
quil = 'RX(%theta) 1'
prog = qf.parse_quil(quil)
assert prog[0].quil() == quil
quil = 'RX(2*%theta) 2'
prog = qf.parse_quil(quil)
print(quil)
assert prog[0].quil() == quil
quil = 'RX(%a*(%b + 2)/(3*%c)) 3'
prog = qf.parse_quil(quil)
print(quil)
assert prog[0].quil() == quil
quil = 'RX(cos(%t)) 4'
prog = qf.parse_quil(quil)
print(quil)
assert prog[0].quil() == quil
def test_defgate_param():
prog = qf.parse_quil(CP)
# ket0 = prog.compile()
# qf.print_state(ket0)
ket1 = prog.run()
qf.print_state(ket1)
ket = qf.zero_state(2)
ket = qf.X(0).run(ket)
ket = qf.X(1).run(ket)
ket = qf.CPHASE(1.0, 0, 1).run(ket)
qf.print_state(ket)
assert qf.states_close(ket1, ket)
def test_classical_moves():
quil = "MOVE b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Move)
assert cmd.quil() == quil
quil = "EXCHANGE b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Exchange)
assert cmd.quil() == quil
# quil = "CONVERT b[0] b[1]"
# cmd = qf.parse_quil(quil)[0]
# assert isinstance(cmd, qf.Convert)
# assert cmd.quil() == quil
quil = "LOAD b[0] this b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Load)
assert cmd.quil() == quil
# assert len(cmd.cbits) == 2
quil = "STORE that b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Store)
assert cmd.quil() == quil
# assert len(cmd.cbits) == 2
quil = "STORE that b[0] 200"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Store)
assert cmd.quil() == quil
# assert len(cmd.cbits) == 1
b = qf.Register('b')
_test("MOVE b[0] b[1]", qf.Move(b[0], b[1]))
_test("EXCHANGE b[0] b[1]", qf.Exchange(b[0], b[1]))
def test_classical():
ro = qf.Register()
quil = "TRUE ro[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.TRUE)
assert cmd.addr == ro[1]
assert cmd.quil() == quil
b = qf.Register('b')
quil = "FALSE b[2]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.FALSE)
assert cmd.addr == b[2]
assert cmd.quil() == quil
quil = "NOT b[3]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Not)
assert cmd.target == b[3]
assert cmd.quil() == quil
quil = "NEG b[3]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Neg)
assert cmd.target == b[3]
assert cmd.quil() == quil
quil = "AND b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.And)
assert cmd.quil() == quil
quil = "IOR b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Ior)
assert cmd.quil() == quil
quil = "XOR b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Xor)
assert cmd.quil() == quil
a = qf.Register('a')
_test("TRUE b[0]", qf.TRUE(b[0]))
_test("FALSE b[0]", qf.FALSE(b[0]))
_test("NOT b[0]", qf.Not(b[0]))
_test("AND b[0] a[1]", qf.And(b[0], a[1]))
_test("XOR b[0] b[1]", qf.Xor(b[0], b[1]))
def test_classical_math():
quil = "ADD b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Add)
assert cmd.quil() == quil
quil = "MUL b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Mul)
assert cmd.quil() == quil
quil = "SUB b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Sub)
assert cmd.quil() == quil
quil = "DIV b[0] b[1]"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Div)
assert cmd.quil() == quil
quil = "ADD b[0] 4"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Add)
assert cmd.quil() == quil
quil = "MUL b[0] 2"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Mul)
assert cmd.quil() == quil
quil = "SUB b[0] 3"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Sub)
assert cmd.quil() == quil
quil = "DIV b[0] 2"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Div)
assert cmd.quil() == quil
def test_defgate():
prog = qf.parse_quil(HADAMARD)
ket = prog.run()
qf.print_state(ket)
assert qf.states_close(ket, qf.ghz_state(1))
def test_comments():
qf.parse_quil('#Comment')
qf.parse_quil('#Comment\n#more comments')
qf.parse_quil('#Comment\n #more comments')
def test_instr_qubits():
prog = qf.parse_quil(QUILPROG)
assert prog.qubits == [0, 1]
prog = qf.parse_quil("RX(3) 1 2 7 3")
assert prog.qubits == [1, 2, 3, 7]
def test_defgate_other():
# Catch Exp, sqrt to string
prog = qf.parse_quil(OTHERGATE)
cmd = prog[0]
# print(cmd)
assert str(cmd) == OTHERGATE
def test_defgate_param():
prog = qf.parse_quil(PHASEGATE)
cmd = prog[0]
print(cmd)
assert str(cmd) == PHASEGATE
def test_prog():
prog = qf.parse_quil(QUILPROG)
assert len(prog) == 11
assert str(prog) == QUILPROG
def test_math():
def get_arg(prog):
return prog[0].params[0]
arg = get_arg(qf.parse_quil("RX(1) 0"))
assert arg == 1
arg = get_arg(qf.parse_quil("RX(2.9) 0"))
assert arg == 2.9
arg = get_arg(qf.parse_quil("RX(-2.9) 0"))
assert arg == -2.9
arg = get_arg(qf.parse_quil("RX(+2.9) 0"))
assert arg == +2.9
arg = get_arg(qf.parse_quil("RX(+2.9/4.2) 0"))
assert arg == +2.9/4.2
arg = get_arg(qf.parse_quil("RX(+2.9*4.2) 0"))
assert arg == +2.9*4.2
arg = get_arg(qf.parse_quil("RX(2.9+4.2) 0"))
assert arg == 2.9+4.2
arg = get_arg(qf.parse_quil("RX(2.9-4.2) 0"))
assert arg == 2.9-4.2
arg = get_arg(qf.parse_quil("RX(pi) 0"))
assert arg == math.pi
arg = get_arg(qf.parse_quil("RX(2.0*pi) 0"))
assert arg == 2.0*math.pi
arg = get_arg(qf.parse_quil("RX(sin(1.0)) 0"))
assert arg == math.sin(1.0)
arg = get_arg(qf.parse_quil("RX(sin(1.0)) 0"))
assert arg == math.sin(1.0)
arg = get_arg(qf.parse_quil("RX(exp(3.3)) 0"))
assert arg == math.exp(3.3)
print(arg, type(arg))
arg = get_arg(qf.parse_quil("RX(cos(2.3)) 0"))
print(arg, type(arg))
assert math.cos(2.3) - arg == ALMOST_ZERO
arg = get_arg(qf.parse_quil("RX( sqrt( 42 ) ) 0"))
assert math.sqrt(42) - arg == ALMOST_ZERO
arg = get_arg(qf.parse_quil("RX(cis(2)) 0"))
assert cmath.isclose(cis(2), arg)
arg = get_arg(qf.parse_quil("RX(2.3 i) 0"))
assert arg == 2.3j
arg = get_arg(qf.parse_quil("RX(exp(2)) 0"))
assert math.exp(2) - arg == ALMOST_ZERO
arg = get_arg(qf.parse_quil("RX(2^2) 0"))
assert 4 - arg == ALMOST_ZERO
def _test(quil_string, *instructions):
prog0 = qf.parse_quil(quil_string)
prog1 = qf.Program(instructions)
assert prog0.quil() == prog1.quil()
def test_label():
quil = "LABEL @some_target"
cmd = qf.parse_quil(quil)[0]
assert isinstance(cmd, qf.Label)
assert cmd.target == "some_target"
assert cmd.quil() == quil