def test_measure_bitstrings(forest):
device = NxDevice(nx.complete_graph(2))
qc_pyqvm = QuantumComputer(name='testy!',
qam=PyQVM(n_qubits=2),
device=device,
compiler=DummyCompiler())
qc_forest = QuantumComputer(name='testy!',
qam=QVM(connection=forest,
gate_noise=[0.00] * 3),
device=device,
compiler=DummyCompiler())
prog = Program(I(0), I(1))
meas_qubits = [0, 1]
sym_progs, flip_array = _symmetrization(prog, meas_qubits, symm_type=-1)
results = _measure_bitstrings(qc_pyqvm,
sym_progs,
meas_qubits,
num_shots=1)
# test with pyQVM
answer = [
np.array([[0, 0]]),
np.array([[0, 1]]),
np.array([[1, 0]]),
np.array([[1, 1]])
]
assert all([np.allclose(x, y) for x, y in zip(results, answer)])
# test with regular QVM
results = _measure_bitstrings(qc_forest,
sym_progs,
meas_qubits,
num_shots=1)
assert all([np.allclose(x, y) for x, y in zip(results, answer)])
def test_readout_symmetrization(forest):
device = NxDevice(nx.complete_graph(3))
noise_model = decoherence_noise_with_asymmetric_ro(gates=gates_in_isa(device.get_isa()))
qc = QuantumComputer(
name='testy!',
qam=QVM(connection=forest, noise_model=noise_model),
device=device,
compiler=DummyCompiler()
)
prog = Program(I(0), X(1),
MEASURE(0, 0),
MEASURE(1, 1))
prog.wrap_in_numshots_loop(1000)
bs1 = qc.run(prog)
avg0_us = np.mean(bs1[:, 0])
avg1_us = 1 - np.mean(bs1[:, 1])
diff_us = avg1_us - avg0_us
assert diff_us > 0.03
bs2 = qc.run_symmetrized_readout(prog, 1000)
avg0_s = np.mean(bs2[:, 0])
avg1_s = 1 - np.mean(bs2[:, 1])
diff_s = avg1_s - avg0_s
assert diff_s < 0.05
def test_qc_joint_expectation(forest):
device = NxDevice(nx.complete_graph(2))
qc = QuantumComputer(
name="testy!", qam=QVM(connection=forest), device=device, compiler=DummyCompiler()
)
# |01> state program
p = Program()
p += RESET()
p += X(0)
p.wrap_in_numshots_loop(10)
# ZZ experiment
sz = ExperimentSetting(
in_state=sZ(0) * sZ(1), out_operator=sZ(0) * sZ(1), additional_expectations=[[0], [1]]
)
e = Experiment(settings=[sz], program=p)
results = qc.experiment(e)
# ZZ expectation value for state |01> is -1
assert np.isclose(results[0].expectation, -1)
assert np.isclose(results[0].std_err, 0)
assert results[0].total_counts == 40
# Z0 expectation value for state |01> is -1
assert np.isclose(results[0].additional_results[0].expectation, -1)
assert results[0].additional_results[1].total_counts == 40
# Z1 expectation value for state |01> is 1
assert np.isclose(results[0].additional_results[1].expectation, 1)
assert results[0].additional_results[1].total_counts == 40
def test_qc_compile():
qc = get_qc('5q', as_qvm=True, noisy=True)
qc.compiler = DummyCompiler()
prog = Program()
prog += H(0)
prog1 = qc.compile(prog)
assert prog1 == prog
def test_for_negative_probabilities():
# trivial program to do state tomography on
prog = Program(I(0))
# make TomographyExperiment
expt_settings = [ExperimentSetting(zeros_state([0]), pt) for pt in [sI(0), sX(0), sY(0), sZ(0)]]
experiment_1q = TomographyExperiment(settings=expt_settings, program=prog)
# make a quantum computer object
device = NxDevice(nx.complete_graph(1))
qc_density = QuantumComputer(
name="testy!",
qam=PyQVM(n_qubits=1, quantum_simulator_type=ReferenceDensitySimulator),
device=device,
compiler=DummyCompiler(),
)
# initialize with a pure state
initial_density = np.array([[1.0, 0.0], [0.0, 0.0]])
qc_density.qam.wf_simulator.density = initial_density
try:
list(measure_observables(qc=qc_density, tomo_experiment=experiment_1q, n_shots=3000))
except ValueError as e:
# the error is from np.random.choice by way of self.rs.choice in ReferenceDensitySimulator
assert str(e) != "probabilities are not non-negative"
# initialize with a mixed state
initial_density = np.array([[0.9, 0.0], [0.0, 0.1]])
qc_density.qam.wf_simulator.density = initial_density
try:
list(measure_observables(qc=qc_density, tomo_experiment=experiment_1q, n_shots=3000))
except ValueError as e:
assert str(e) != "probabilities are not non-negative"
def test_reset(forest):
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(name='testy!',
qam=QVM(connection=forest),
device=device,
compiler=DummyCompiler())
p = Program(Declare(name='theta', memory_type='REAL'),
Declare(name='ro', memory_type='BIT'),
RX(MemoryReference('theta'), 0),
MEASURE(0, MemoryReference('ro'))).wrap_in_numshots_loop(1000)
qc.run(executable=p, memory_map={'theta': [np.pi]})
aref = ParameterAref(name='theta', index=0)
assert qc.qam._variables_shim[aref] == np.pi
assert qc.qam._executable == p
assert qc.qam._memory_results["ro"].shape == (1000, 1)
assert all([bit == 1 for bit in qc.qam._memory_results["ro"]])
assert qc.qam.status == 'done'
qc.reset()
assert qc.qam._variables_shim == {}
assert qc.qam._executable is None
assert qc.qam._memory_results["ro"] is None
assert qc.qam.status == 'connected'
def test_qc_compile():
qc = get_qc("5q", as_qvm=True, noisy=True)
qc.compiler = DummyCompiler()
prog = Program()
prog += H(0)
exe = qc.compile(prog)
prog1 = Program(exe.program)
assert isinstance(exe, PyQuilExecutableResponse)
assert prog1 == prog
def test_device_stuff():
topo = nx.from_edgelist([(0, 4), (0, 99)])
qc = QuantumComputer(
name='testy!',
qam=None, # not necessary for this test
device=NxDevice(topo),
compiler=DummyCompiler())
assert nx.is_isomorphic(qc.qubit_topology(), topo)
isa = qc.get_isa(twoq_type='CPHASE')
assert sorted(isa.edges)[0].type == 'CPHASE'
assert sorted(isa.edges)[0].targets == [0, 4]
def test_run_pyqvm_noiseless():
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(
name="testy!", qam=PyQVM(n_qubits=3), device=device, compiler=DummyCompiler()
)
prog = Program(H(0), CNOT(0, 1), CNOT(1, 2))
ro = prog.declare("ro", "BIT", 3)
for q in range(3):
prog += MEASURE(q, ro[q])
bitstrings = qc.run(prog.wrap_in_numshots_loop(1000))
assert bitstrings.shape == (1000, 3)
parity = np.sum(bitstrings, axis=1) % 3
assert np.mean(parity) == 0
def test_run_with_parameters(forest):
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(name='testy!',
qam=QVM(connection=forest),
device=device,
compiler=DummyCompiler())
bitstrings = qc.run(executable=Program(
Declare(name='theta', memory_type='REAL'),
Declare(name='ro', memory_type='BIT'), RX(MemoryReference('theta'), 0),
MEASURE(0, MemoryReference('ro'))).wrap_in_numshots_loop(1000),
memory_map={'theta': [np.pi]})
assert bitstrings.shape == (1000, 1)
assert all([bit == 1 for bit in bitstrings])
def test_run(forest):
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(name='testy!',
qam=QVM(connection=forest, gate_noise=[0.01] * 3),
device=device,
compiler=DummyCompiler())
bitstrings = qc.run(
Program(H(0), CNOT(0, 1), CNOT(1, 2),
MEASURE(0, MemoryReference("ro", 0)),
MEASURE(1, MemoryReference("ro", 1)),
MEASURE(2, MemoryReference("ro",
2))).wrap_in_numshots_loop(1000))
assert bitstrings.shape == (1000, 3)
parity = np.sum(bitstrings, axis=1) % 3
assert 0 < np.mean(parity) < 0.15
def test_run_pyqvm_noisy():
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(
name='testy!',
qam=PyQVM(n_qubits=3,
post_gate_noise_probabilities={'relaxation': 0.01}),
device=device,
compiler=DummyCompiler())
prog = Program(H(0), CNOT(0, 1), CNOT(1, 2))
ro = prog.declare('ro', 'BIT', 3)
for q in range(3):
prog += MEASURE(q, ro[q])
bitstrings = qc.run(prog.wrap_in_numshots_loop(1000))
assert bitstrings.shape == (1000, 3)
parity = np.sum(bitstrings, axis=1) % 3
assert 0 < np.mean(parity) < 0.15
def test_run_with_parameters(forest):
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(
name="testy!", qam=QVM(connection=forest), device=device, compiler=DummyCompiler()
)
bitstrings = qc.run(
executable=Program(
Declare(name="theta", memory_type="REAL"),
Declare(name="ro", memory_type="BIT"),
RX(MemoryReference("theta"), 0),
MEASURE(0, MemoryReference("ro")),
).wrap_in_numshots_loop(1000),
memory_map={"theta": [np.pi]},
)
assert bitstrings.shape == (1000, 1)
assert all([bit == 1 for bit in bitstrings])
def test_qc_expectation_larger_lattice(forest):
device = NxDevice(nx.complete_graph(4))
qc = QuantumComputer(name='testy!',
qam=QVM(connection=forest),
device=device,
compiler=DummyCompiler())
q0 = 2
q1 = 3
# bell state program
p = Program()
p += RESET()
p += H(q0)
p += CNOT(q0, q1)
p.wrap_in_numshots_loop(10)
# XX, YY, ZZ experiment
sx = ExperimentSetting(in_state=sZ(q0) * sZ(q1),
out_operator=sX(q0) * sX(q1))
sy = ExperimentSetting(in_state=sZ(q0) * sZ(q1),
out_operator=sY(q0) * sY(q1))
sz = ExperimentSetting(in_state=sZ(q0) * sZ(q1),
out_operator=sZ(q0) * sZ(q1))
e = TomographyExperiment(settings=[sx, sy, sz], program=p)
results = qc.experiment(e)
# XX expectation value for bell state |00> + |11> is 1
assert np.isclose(results[0].expectation, 1)
assert np.isclose(results[0].std_err, 0)
assert results[0].total_counts == 40
# YY expectation value for bell state |00> + |11> is -1
assert np.isclose(results[1].expectation, -1)
assert np.isclose(results[1].std_err, 0)
assert results[1].total_counts == 40
# ZZ expectation value for bell state |00> + |11> is 1
assert np.isclose(results[2].expectation, 1)
assert np.isclose(results[2].std_err, 0)
assert results[2].total_counts == 40
def test_run_pyqvm_noiseless():
device = NxDevice(nx.complete_graph(3))
qc = QuantumComputer(
name='testy!',
qam=PyQVM(n_qubits=3),
device=device,
compiler=DummyCompiler()
)
bitstrings = qc.run(
Program(
H(0),
CNOT(0, 1),
CNOT(1, 2),
MEASURE(0, 0),
MEASURE(1, 1),
MEASURE(2, 2)).wrap_in_numshots_loop(1000)
)
assert bitstrings.shape == (1000, 3)
parity = np.sum(bitstrings, axis=1) % 3
assert np.mean(parity) == 0
def test_qc_expectation_on_qvm_that_requires_executable(forest):
# regression test for https://github.com/rigetti/forest-tutorials/issues/2
device = NxDevice(nx.complete_graph(2))
qc = QuantumComputer(
name="testy!",
qam=QVM(connection=forest, requires_executable=True),
device=device,
compiler=DummyCompiler(),
)
p = Program()
theta = p.declare("theta", "REAL")
p += RESET()
p += RY(theta, 0)
p.wrap_in_numshots_loop(10000)
sx = ExperimentSetting(in_state=sZ(0), out_operator=sX(0))
e = Experiment(settings=[sx], program=p)
thetas = [-np.pi / 2, 0.0, np.pi / 2]
results = []
# Verify that multiple calls to qc.experiment with the same experiment backed by a QVM that
# requires_exectutable does not raise an exception.
for theta in thetas:
results.append(qc.experiment(e, memory_map={"theta": [theta]}))
assert np.isclose(results[0][0].expectation, -1.0, atol=0.01)
assert np.isclose(results[0][0].std_err, 0)
assert results[0][0].total_counts == 20000
# bounds on atol and std_err here are a little loose to try and avoid test flakiness.
assert np.isclose(results[1][0].expectation, 0.0, atol=0.1)
assert results[1][0].std_err < 0.01
assert results[1][0].total_counts == 20000
assert np.isclose(results[2][0].expectation, 1.0, atol=0.01)
assert np.isclose(results[2][0].std_err, 0)
assert results[2][0].total_counts == 20000
def test_set_initial_state():
# That is test the assigned state matrix in ReferenceDensitySimulator is persistent between
# rounds of run.
rho1 = np.array([[0.0, 0.0], [0.0, 1.0]])
# run prog
prog = Program(I(0))
ro = prog.declare("ro", "BIT", 1)
prog += MEASURE(0, ro[0])
# make a quantum computer object
device = NxDevice(nx.complete_graph(1))
qc_density = QuantumComputer(
name="testy!",
qam=PyQVM(n_qubits=1,
quantum_simulator_type=ReferenceDensitySimulator),
device=device,
compiler=DummyCompiler(),
)
qc_density.qam.wf_simulator.set_initial_state(rho1).reset()
out = [qc_density.run(prog) for _ in range(0, 4)]
ans = [np.array([[1]]), np.array([[1]]), np.array([[1]]), np.array([[1]])]
assert all([np.allclose(x, y) for x, y in zip(out, ans)])
# Run and measure style
progRAM = Program(I(0))
results = qc_density.run_and_measure(progRAM, trials=10)
ans = {0: np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])}
assert np.allclose(results[0], ans[0])
# test reverting ReferenceDensitySimulator to the default state
rho0 = np.array([[1.0, 0.0], [0.0, 0.0]])
qc_density.qam.wf_simulator.set_initial_state(rho0).reset()
assert np.allclose(qc_density.qam.wf_simulator.density, rho0)
assert np.allclose(qc_density.qam.wf_simulator.initial_density, rho0)