def test_if():
circ = qf.Circuit()
c = qf.Register('c')
circ += qf.Move(c[0], 0)
circ += qf.Move(c[1], 1)
circ += qf.If(qf.X(0), c[1])
circ += qf.Measure(0, c[0])
ket = circ.run()
assert ket.memory[c[0]] == 1
assert circ.evolve().memory[c[0]] == 1
circ = qf.Circuit()
c = qf.Register('c')
circ += qf.Move(c[0], 0)
circ += qf.Move(c[1], 0)
circ += qf.If(qf.X(0), c[1])
circ += qf.Measure(0, c[0])
ket = circ.run()
assert ket.memory[c[0]] == 0
assert circ.evolve().memory[c[0]] == 0
circ = qf.Circuit()
c = qf.Register('c')
circ += qf.Move(c[0], 0)
circ += qf.Move(c[1], 0)
circ += qf.If(qf.X(0), c[1], value=False)
circ += qf.Measure(0, c[0])
ket = circ.run()
assert ket.memory[c[0]] == 1
assert circ.evolve().memory[c[0]] == 1
def test_register_ordered():
assert qf.Register() == qf.Register('ro')
assert qf.Register('a') < qf.Register('b')
assert qf.Register('a') != qf.Register('b')
assert qf.Register('c') != 'foobar'
with pytest.raises(TypeError):
qf.Register('c') < 'foobar'
def test_classical():
ro = qf.Register()
quil = "TRUE ro[1]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.Move)
assert cmd.target == ro[1]
assert cmd.quil() == 'MOVE ro[1] 1'
b = qf.Register('b')
quil = "FALSE b[2]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.Move)
assert cmd.target == b[2]
assert cmd.quil() == 'MOVE b[2] 0'
quil = "NOT b[3]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.Not)
assert cmd.target == b[3]
assert cmd.quil() == quil
quil = "NEG b[3]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.Neg)
assert cmd.target == b[3]
assert cmd.quil() == quil
quil = "AND b[0] b[1]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.And)
assert cmd.quil() == quil
quil = "IOR b[0] b[1]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.Ior)
assert cmd.quil() == quil
quil = "XOR b[0] b[1]"
cmd = qf.forest.quil_to_program(quil)[0]
assert isinstance(cmd, qf.Xor)
assert cmd.quil() == quil
a = qf.Register('a')
_test("TRUE b[0]", qf.Move(b[0], 1))
_test("FALSE b[0]", qf.Move(b[0], 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():
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_addr():
c = qf.Register('c')
c0 = c[0]
assert c0.register.name == 'c'
assert c0.key == 0
assert c0.register.dtype == 'BIT'
assert str(c0) == 'c[0]'
assert repr(c0) == "Register('c', 'BIT')[0]"
def test_div():
ro = qf.Register()
prog = qf.Program()
prog += qf.Move(ro[0], 4)
prog += qf.Move(ro[1], 1)
prog += qf.Div(ro[0], ro[1])
prog += qf.Div(ro[0], 2)
ket = prog.run()
assert ket.memory[ro[0]] == 2
def test_density_add():
ro = qf.Register()
circ = qf.Circuit()
circ += qf.Move(ro[0], 1)
circ += qf.Move(ro[1], 2)
circ += qf.Add(ro[0], ro[1])
circ += qf.Add(ro[0], 4)
rho = circ.evolve()
assert rho.memory[ro[0]] == 7
def test_sub():
ro = qf.Register()
prog = qf.Program()
prog += qf.Move(ro[0], 1)
prog += qf.Move(ro[1], 2)
prog += qf.Sub(ro[0], ro[1])
prog += qf.Sub(ro[0], 4)
prog += qf.Neg(ro[0])
ket = prog.run()
assert ket.memory[ro[0]] == 5
def test_halt():
ro = qf.Register()
prog = qf.Program()
prog += qf.FALSE(ro[0])
prog += qf.Halt()
prog += qf.Not(ro[0])
ket = prog.run()
assert ket.memory[PC] == -1
assert ket.memory[ro[0]] == 0
def test_reset():
ro = qf.Register()
prog = qf.Program()
prog += qf.Move(ro[0], 1)
prog += qf.Call('X', params=[], qubits=[0])
prog += qf.Reset()
prog += qf.Measure(0, ro[1])
ket = prog.run()
assert ket.qubits == (0, )
assert ket.memory[ro[0]] == 1
assert ket.memory[ro[1]] == 0
def test_wait():
ro = qf.Register()
prog = qf.Program()
prog += qf.FALSE(ro[0])
prog += qf.Wait()
prog += qf.Not(ro[0])
prog += qf.Wait()
prog += qf.Not(ro[0])
prog += qf.Wait()
prog += qf.Not(ro[0])
ket = prog.run()
assert ket.memory[ro[0]] == 1
def test_comparisions():
ro = qf.Register()
prog = qf.Program()
prog += qf.Move(ro[0], 1)
prog += qf.Move(ro[1], 2)
prog += qf.EQ(('eq', 0), ro[0], ro[1])
prog += qf.GT(('gt', 0), ro[0], ro[1])
prog += qf.GE(('ge', 0), ro[0], ro[1])
prog += qf.LT(('lt', 0), ro[0], ro[1])
prog += qf.LE(('le', 0), ro[0], ro[1])
ket = prog.run()
assert ket.memory[('eq', 0)] == 0
assert ket.memory[('gt', 0)] == 0
assert ket.memory[('ge', 0)] == 0
assert ket.memory[('lt', 0)] == 1
assert ket.memory[('le', 0)] == 1
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_density_memory():
rho0 = qf.zero_state(1).asdensity()
assert rho0.memory == {}
ro = qf.Register('ro')
rho1 = rho0.update({ro[1]: 1})
assert rho0.memory == {}
assert rho1.memory == {ro[1]: 1}
assert rho1.cbit_nb == 1
assert rho1.cbits == (ro[1], )
rho2 = qf.H(0).aschannel().evolve(rho1)
assert rho2.memory == rho2.memory
rho3 = qf.X(0).evolve(rho1)
assert rho3.memory == rho2.memory
def test_memory():
ket0 = qf.zero_state(1)
assert ket0.memory == {}
ro = qf.Register('ro')
ket1 = ket0.update({ro[1]: 1})
assert ket0.memory == {}
assert ket1.memory == {ro[1]: 1}
assert ket1.cbit_nb == 1
assert ket1.cbits == (ro[1], )
ket2 = qf.H(0).run(ket1)
assert ket2.memory == ket1.memory
ket3 = ket2.update({ro[1]: 0, ro[0]: 0})
assert ket3.memory == {ro[0]: 0, ro[1]: 0}
assert ket3.cbits == (ro[0], ro[1])
def test_jump():
ro = qf.Register()
prog = qf.Program()
prog += qf.FALSE(ro[0])
prog += qf.Jump('There')
prog += qf.Not(ro[0])
prog += qf.Label('There')
prog += qf.Not(ro[0])
ket = prog.run()
assert ket.memory[ro[0]] == 1
prog += qf.JumpWhen('There', ro[0])
ket = prog.run()
assert ket.memory[ro[0]] == 0
prog += qf.Not(ro[0])
prog += qf.JumpUnless('There', ro[0])
ket = prog.run()
assert ket.memory[ro[0]] == 1
def test_logics():
c = qf.Register('c')
circ = qf.Circuit([qf.Move(c[0], 0),
qf.Move(c[1], 1),
qf.And(c[0], c[1])])
# assert len(circ) == 3 # FIXME
# assert circ.cbits == [c[0], c[1]] # FIXME
ket = circ.run()
assert ket.memory == {c[0]: 0, c[1]: 1}
circ += qf.Not(c[1])
circ += qf.And(c[0], c[1])
ket = circ.run(ket)
assert ket.memory == {c[0]: 0, c[1]: 0}
circ = qf.Circuit()
circ += qf.Move(c[0], 0)
circ += qf.Move(c[1], 1)
circ += qf.Ior(c[0], c[1])
ket = circ.run()
assert ket.memory == {c[0]: 1, c[1]: 1}
circ = qf.Circuit()
circ += qf.Move(c[0], 1)
circ += qf.Move(c[1], 1)
circ += qf.Xor(c[0], c[1])
ket = circ.run()
assert ket.memory == {c[0]: 0, c[1]: 1}
circ += qf.Exchange(c[0], c[1])
ket = circ.run(ket)
assert ket.memory == {c[0]: 1, c[1]: 0}
circ += qf.Move(c[0], c[1])
ket = circ.run(ket)
assert ket.memory == {c[0]: 0, c[1]: 0}
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_jumps2():
_test("LABEL @test_1", qf.Label("test_1"))
_test("JUMP @test_1", qf.Jump("test_1"))
cb = qf.Register('cb')
_test("JUMP-WHEN @test_1 cb[0]", qf.JumpWhen("test_1", cb[0]))
_test("JUMP-UNLESS @test_1 cb[1]", qf.JumpUnless("test_1", cb[1]))
def test_neg():
c = qf.Register('c')
assert str(qf.Neg(c[10])) == 'NEG c[10]'
def test_addr_ordered():
key = qf.Register('c')[0]
d = dict({key: '1234'})
assert d[key] == '1234'
assert qf.Register('c')[0] == qf.Register('c')[0]
assert qf.Register('c')[0] != qf.Register('c')[1]
assert qf.Register('d')[0] != qf.Register('c')[0]
assert qf.Register('c')[0] != 'foobar'
assert qf.Register('c')[0] < qf.Register('c')[1]
with pytest.raises(TypeError):
qf.Register('c')[0] < 'foobar'
def test_register():
ro = qf.Register()
assert ro.name == 'ro'
assert str(ro) == "Register('ro', 'BIT')"
