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, MemoryReference("ro", 0)),
MEASURE(1, MemoryReference("ro", 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_readout_symmetrization(client_configuration: QCSClientConfiguration):
quantum_processor = NxQuantumProcessor(nx.complete_graph(3))
noise_model = decoherence_noise_with_asymmetric_ro(quantum_processor.to_compiler_isa())
qc = QuantumComputer(
name="testy!",
qam=QVM(client_configuration=client_configuration, noise_model=noise_model),
compiler=DummyCompiler(quantum_processor=quantum_processor, client_configuration=client_configuration),
)
prog = Program(
Declare("ro", "BIT", 2),
I(0),
X(1),
MEASURE(0, MemoryReference("ro", 0)),
MEASURE(1, MemoryReference("ro", 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
prog = Program(
I(0),
X(1),
)
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_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_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_qvm_run_region_not_declared_is_measured_ro(
client_configuration: QCSClientConfiguration):
qvm = QVM(client_configuration=client_configuration)
p = Program(X(0), MEASURE(0, MemoryReference("ro")))
with pytest.raises(QVMError) as excinfo:
qvm.load(p.wrap_in_numshots_loop(100)).run().wait()
assert 'Bad memory region' in str(excinfo)
def test_qvm_run_region_not_declared_is_measured_non_ro(forest: ForestConnection):
qvm = QVM(connection=forest)
p = Program(X(0), MEASURE(0, MemoryReference("reg")))
nq = PyQuilExecutableResponse(program=p.out(), attributes={"num_shots": 100})
with pytest.raises(QVMError, match='Bad memory region name "reg" in MEASURE'):
qvm.load(nq).run().wait()
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_qvm_run_region_not_declared_is_measured_ro(forest: ForestConnection):
qvm = QVM(connection=forest)
p = Program(X(0), MEASURE(0, MemoryReference("ro")))
nq = PyQuilExecutableResponse(program=p.out(), attributes={"num_shots": 100})
qvm.load(nq).run().wait()
bitstrings = qvm.read_memory(region_name="ro")
assert bitstrings.shape == (100, 1)
def test_qvm_run_region_not_declared_is_measured_non_ro(
client_configuration: QCSClientConfiguration):
qvm = QVM(client_configuration=client_configuration)
p = Program(X(0), MEASURE(0, MemoryReference("reg")))
with pytest.raises(QVMError,
match='Bad memory region name "reg" in MEASURE'):
qvm.load(p).run().wait()
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_qvm_run_region_declared_and_measured(
client_configuration: QCSClientConfiguration):
qvm = QVM(client_configuration=client_configuration)
p = Program(Declare("reg", "BIT"), X(0), MEASURE(0,
MemoryReference("reg")))
qvm.load(p.wrap_in_numshots_loop(100)).run().wait()
bitstrings = qvm.read_memory(region_name="reg")
assert bitstrings.shape == (100, 1)
def test_qvm_run_just_program(client_configuration: QCSClientConfiguration):
qvm = QVM(client_configuration=client_configuration,
gate_noise=(0.01, 0.01, 0.01))
p = Program(Declare("ro", "BIT"), X(0), MEASURE(0, MemoryReference("ro")))
result = qvm.run(p.wrap_in_numshots_loop(1000))
bitstrings = result.readout_data.get("ro")
assert bitstrings.shape == (1000, 1)
assert np.mean(bitstrings) > 0.8
def test_qvm_run_region_declared_and_measured(
client_configuration: QCSClientConfiguration):
qvm = QVM(client_configuration=client_configuration)
p = Program(Declare("reg", "BIT"), X(0), MEASURE(0,
MemoryReference("reg")))
result = qvm.run(p.wrap_in_numshots_loop(100))
bitstrings = result.readout_data.get("reg")
assert bitstrings.shape == (100, 1)
def test_run_with_bad_parameters(client_configuration: QCSClientConfiguration,
param):
quantum_processor = NxQuantumProcessor(nx.complete_graph(3))
qc = QuantumComputer(
name="testy!",
qam=QVM(client_configuration=client_configuration),
compiler=DummyCompiler(quantum_processor=quantum_processor,
client_configuration=client_configuration),
)
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)
with pytest.raises(TypeError, match=r"Parameter must be"):
executable.write_memory(region_name="theta", value=param)
def test_qvm_run_just_program(client_configuration: QCSClientConfiguration):
qvm = QVM(client_configuration=client_configuration,
gate_noise=(0.01, 0.01, 0.01))
p = Program(Declare("ro", "BIT"), X(0), MEASURE(0, MemoryReference("ro")))
qvm.load(p.wrap_in_numshots_loop(1000))
qvm.run()
qvm.wait()
bitstrings = qvm.read_memory(region_name="ro")
assert bitstrings.shape == (1000, 1)
assert np.mean(bitstrings) > 0.8
def test_qvm_run_just_program(forest: ForestConnection):
qvm = QVM(connection=forest, gate_noise=[0.01] * 3)
p = Program(Declare("ro", "BIT"), X(0), MEASURE(0, MemoryReference("ro")))
p.wrap_in_numshots_loop(1000)
qvm.load(p)
qvm.run()
qvm.wait()
bitstrings = qvm.read_memory(region_name="ro")
assert bitstrings.shape == (1000, 1)
assert np.mean(bitstrings) > 0.8
def test_run_with_parameters(client_configuration: QCSClientConfiguration):
quantum_processor = NxQuantumProcessor(nx.complete_graph(3))
qc = QuantumComputer(
name="testy!",
qam=QVM(client_configuration=client_configuration),
compiler=DummyCompiler(quantum_processor=quantum_processor, client_configuration=client_configuration),
)
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_qvm_run_pqer(forest: ForestConnection):
qvm = QVM(connection=forest, gate_noise=[0.01] * 3)
p = Program(Declare("ro", "BIT"), X(0), MEASURE(0, MemoryReference("ro")))
p.wrap_in_numshots_loop(1000)
nq = PyQuilExecutableResponse(program=p.out(), attributes={"num_shots": 1000})
qvm.load(nq)
qvm.run()
qvm.wait()
bitstrings = qvm.read_memory(region_name="ro")
assert bitstrings.shape == (1000, 1)
assert np.mean(bitstrings) > 0.8
def test_reset(client_configuration: QCSClientConfiguration):
quantum_processor = NxQuantumProcessor(nx.complete_graph(3))
qc = QuantumComputer(
name="testy!",
qam=QVM(client_configuration=client_configuration),
compiler=DummyCompiler(quantum_processor=quantum_processor,
client_configuration=client_configuration),
)
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(10)
p.write_memory(region_name="theta", value=np.pi)
result = qc.qam.run(p)
aref = ParameterAref(name="theta", index=0)
assert p._memory.values[aref] == np.pi
assert result.readout_data["ro"].shape == (10, 1)
assert all([bit == 1 for bit in result.readout_data["ro"]])
def test_run(client_configuration: QCSClientConfiguration):
quantum_processor = NxQuantumProcessor(nx.complete_graph(3))
qc = QuantumComputer(
name="testy!",
qam=QVM(client_configuration=client_configuration, gate_noise=(0.01, 0.01, 0.01)),
compiler=DummyCompiler(quantum_processor=quantum_processor, client_configuration=client_configuration),
)
bitstrings = qc.run(
Program(
Declare("ro", "BIT", 3),
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_qvm_run_only_pqer(forest: ForestConnection):
qvm = QVM(connection=forest, gate_noise=[0.01] * 3, requires_executable=True)
p = Program(Declare("ro", "BIT"), X(0), MEASURE(0, MemoryReference("ro")))
p.wrap_in_numshots_loop(1000)
with pytest.raises(TypeError) as e:
qvm.load(p)
qvm.run()
qvm.wait()
assert e.match(r".*Make sure you have explicitly compiled your program.*")
nq = PyQuilExecutableResponse(program=p.out(), attributes={"num_shots": 1000})
qvm.load(nq)
qvm.run()
qvm.wait()
bitstrings = qvm.read_memory(region_name="ro")
assert bitstrings.shape == (1000, 1)
assert np.mean(bitstrings) > 0.8
def test_qvm_compile_pickiness(forest):
p = Program(Declare("ro", "BIT"), X(0), MEASURE(0, MemoryReference("ro")))
p.wrap_in_numshots_loop(1000)
nq = PyQuilExecutableResponse(program=p.out(), attributes={"num_shots": 1000})
# Ok, non-realistic
qc = get_qc("9q-qvm")
qc.run(p)
# Also ok
qc.run(nq)
# Not ok
qc = get_qc("9q-square-qvm")
with pytest.raises(TypeError):
qc.run(p)
# Yot ok
qc.run(nq)
def addr_subscript(self, name, subscript):
return MemoryReference(str(name), int(subscript))
def addr(self, name):
return MemoryReference(str(name))