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_pyquil_program():
"""Tests if the Dynamic Decoupling Sequence gives rise to Identity
operation in PyQuil
"""
_duration = 5e-6
_offsets = [0, 1e-6, 2.5e-6, 4e-6, 5e-6]
_rabi_rotations = [np.pi / 2, np.pi / 2, np.pi, 0, np.pi / 2]
_azimuthal_angles = [0, 0, np.pi / 2, 0, 0]
_detuning_rotations = [0, 0, 0, np.pi, 0]
sequence = DynamicDecouplingSequence(
duration=_duration,
offsets=_offsets,
rabi_rotations=_rabi_rotations,
azimuthal_angles=_azimuthal_angles,
detuning_rotations=_detuning_rotations)
program = convert_dds_to_pyquil_program(sequence, [0], gate_time=1e-6)
assert len(program) == 13
assert program[0] == Pragma("PRESERVE_BLOCK")
assert program[-1] == Pragma("END_PRESERVE_BLOCK")
assert program[1] == RX(np.pi / 2, 0)
assert program[2] == I(0)
assert program[3] == RX(np.pi / 2, 0)
assert program[4] == I(0)
assert program[5] == RY(np.pi, 0)
assert program[6] == I(0)
assert program[7] == RZ(np.pi, 0)
assert program[8] == I(0)
assert program[9] == RX(np.pi / 2, 0)
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 getFile(f):
del states[:]
del rhythm[:]
file = open(askopenfilename(), "r")
for line in file:
p = Program()
p.inst(I(0)) if line[2] == "0" else p.inst(X(0))
p.inst(I(1)) if line[1] == "0" else p.inst(X(1))
p.inst(I(2)) if line[0] == "0" else p.inst(X(2))
rhythm.append(float(line[4:])) if len(line) >= 5 else rhythm.append(1)
states.append(p)
for i in range(0, len(states)):
backup.append(copy.deepcopy(states[i]))
def meyer_penny_program():
"""
Returns the program to simulate the Meyer-Penny Game
:return: pyQuil Program
"""
picard_register = 1
answer_register = 0
then_branch = pq.Program(X(0))
else_branch = pq.Program(I(0))
return (pq.Program()
# Prepare Qubits in Heads state or superposition, respectively
.inst(X(0), H(1))
# Q puts the coin into a superposition
.inst(H(0))
# Picard makes a decision and acts accordingly
.measure(1, picard_register)
.if_then(picard_register, then_branch, else_branch)
# Q undoes his superposition operation
.inst(H(0))
# The outcome is recorded into the answer register
.measure(0, answer_register))
def estimate_assignment_probs(
q: int,
trials: int,
cxn: Union["QVMConnection", "QPUConnection"],
p0: Optional["Program"] = None,
) -> np.ndarray:
"""
Estimate the readout assignment probabilities for a given qubit ``q``.
The returned matrix is of the form::
[[p00 p01]
[p10 p11]]
:param q: The index of the qubit.
:param trials: The number of samples for each state preparation.
:param cxn: The quantum abstract machine to sample from.
:param p0: A header program to prepend to the state preparation programs.
:return: The assignment probability matrix
"""
from pyquil.quil import Program
if p0 is None: # pragma no coverage
p0 = Program()
results_i = np.sum(
cxn.run(p0 + Program(I(q), MEASURE(q, MemoryReference("ro", 0))), [0],
trials))
results_x = np.sum(
cxn.run(p0 + Program(X(q), MEASURE(q, MemoryReference("ro", 0))), [0],
trials))
p00 = 1.0 - results_i / float(trials)
p11 = results_x / float(trials)
return np.array([[p00, 1 - p11], [1 - p00, p11]])
def reset(self, problem_id=None):
"""Reset the state of the environment.
This clears out whatever program you may have assembled so far, and
updates the active problem.
Args:
problem_id: The numeric index of the problem (relative to the problem set).
If None, a random problem will be chosen.
"""
if problem_id is None:
problem_id = np.random.randint(0, self.pset.num_problems())
self.problem_id = problem_id
self._prob_vec = self.pset.problem(self.problem_id)
# the scoring function (for reward computation)
self._prob_score = self.pset.bitstrings_score(self.problem_id)
# we put some trivial gates on each relevant qubit, so that we can
# always recover the problem variables from the program itself
self.program = Program([I(q) for q in range(self.num_qubits)])
self.current_step = 0
self.running_episode_reward = 0
self.bitstrings, info = self._run_program(self.program)
return self.observation
def benchmarker():
try:
bm = get_benchmarker()
bm.apply_clifford_to_pauli(Program(I(0)), sI(0))
except RequestException as e:
return pytest.skip("This test requires a running local benchmarker endpoint (ie quilc): {}"
.format(e))
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_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 orig_decode(qubits, indices=None, measure=True):
## indices are qubits you recover secret from, need 3
## measure asks whether or not to measure result at end
if indices is None:
indices = np.random.choice(len(qubits), 3, replace=False)
new_qubits = [qubits[index] for index in indices]
pq = Program()
ro = pq.declare('ro', 'BIT', 3)
# first hadamard qubit 0
pq += H(new_qubits[0])
# bell state measurement on 1,2
pq += X(new_qubits[2])
pq += CNOT(new_qubits[2], new_qubits[1])
pq += H(new_qubits[2])
pq += MEASURE(new_qubits[1], ro[0])
pq += MEASURE(new_qubits[2], ro[1])
case1 = Program()
case2 = Program()
case1.if_then(ro[1], Program(Z(new_qubits[0]), X(new_qubits[0])),
Z(new_qubits[0]))
case2.if_then(ro[1], X(new_qubits[0]), I(new_qubits[0]))
pq.if_then(ro[0], case1, case2)
if measure:
pq += MEASURE(new_qubits[0], ro[2])
return pq, new_qubits
def cxn():
# DEPRECATED
try:
cxn = QVMConnection(endpoint='http://localhost:5000')
cxn.run(Program(I(0), MEASURE(0, 0)), [0])
return cxn
except RequestException as e:
return pytest.skip("This test requires a running local QVM: {}".format(e))
def qvm():
try:
qc = get_qc('9q-square-qvm')
qc.compiler.client.timeout = 1
qc.run_and_measure(Program(I(0)), trials=1)
return qc
except (RequestException, TimeoutError) as e:
return pytest.skip("This test requires a running local QVM and quilc: {}".format(e))
def compiler():
try:
compiler = CompilerConnection(isa_source=ISA.from_dict(isa_dict()))
compiler.compile(Program(I(0)))
return compiler
except (RequestException, UnknownApiError) as e:
return pytest.skip(
"This test requires compiler connection: {}".format(e))
def qpu_compiler(test_device):
try:
config = PyquilConfig()
compiler = QPUCompiler(endpoint=config.compiler_url, device=test_device, timeout=0.5)
compiler.quil_to_native_quil(Program(I(0)))
return compiler
except Exception as e:
return pytest.skip(f"This test requires compiler connection: {e}")
def compiler(test_device):
try:
config = PyquilConfig()
compiler = LocalQVMCompiler(endpoint=config.compiler_url, device=test_device)
compiler.quil_to_native_quil(Program(I(0)))
return compiler
except (RequestException, UnknownApiError) as e:
return pytest.skip("This test requires compiler connection: {}".format(e))
