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_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_transform_cirq_circuit_with_explicit_decompose(
parametric_circuit_with_params: Tuple[cirq.Circuit, cirq.Linspace],
) -> None:
"""test that a user add a custom circuit decomposition function"""
parametric_circuit, param_resolvers = parametric_circuit_with_params
parametric_circuit.append(cirq.I(cirq.GridQubit(0, 0)))
parametric_circuit.append(cirq.I(cirq.GridQubit(0, 1)))
parametric_circuit.append(
cirq.measure(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), key='m'),
)
circuit = cirq.protocols.resolve_parameters(parametric_circuit, param_resolvers[1])
def decompose_operation(operation: cirq.Operation) -> List[cirq.Operation]:
operations = [operation]
if isinstance(operation.gate, cirq.MeasurementGate) and operation.gate.num_qubits() == 1:
operations.append(cirq.I(operation.qubits[0]))
return operations
program, _ = transformers.build(
decompose_operation=decompose_operation,
)(circuit=circuit)
assert (
RX(np.pi / 2, 2) in program.instructions
), "executable should contain an RX(pi) 0 instruction"
assert I(0) in program.instructions, "executable should contain an I(0) instruction"
assert I(1) in program.instructions, "executable should contain an I(1) instruction"
assert I(2) in program.instructions, "executable should contain an I(2) instruction"
assert DECLARE("m0") in program.instructions, "executable should declare a read out bit"
assert (
MEASURE(0, ("m0", 0)) in program.instructions
), "executable should measure the read out bit"
def test_measure_bitstrings(client_configuration: QCSClientConfiguration):
quantum_processor = NxQuantumProcessor(nx.complete_graph(2))
dummy_compiler = DummyCompiler(quantum_processor=quantum_processor,
client_configuration=client_configuration)
qc_pyqvm = QuantumComputer(name="testy!",
qam=PyQVM(n_qubits=2),
compiler=dummy_compiler)
qc_forest = QuantumComputer(
name="testy!",
qam=QVM(client_configuration=client_configuration,
gate_noise=(0.00, 0.00, 0.00)),
compiler=dummy_compiler,
)
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 period_helper(a, N, size):
c1 = QubitPlaceholder()
zero = QubitPlaceholder()
x = QubitPlaceholder.register(size)
b = QubitPlaceholder.register(size + 1)
#takes in x and b as zero, finds
p = Program()
n = 2 * size
def_regs = Program()
period_regs = def_regs.declare('ro', 'BIT', n)
#For one reg, we want H, CUA, R_i m_i, X^m_i
for i in range(n - 1, -1, -1):
R = Program()
R += H(c1)
for j in range(i - 1, -1, -1):
k = i - j + 1
doit = Program()
doit += RK(k)(c1).dagger()
R = Program().if_then(period_regs[j], doit, I(c1)) + R
R += MEASURE(c1, period_regs[i])
R += Program().if_then(period_regs[i], X(c1), I(c1))
#R = Program(H(c1)) + R
R = Program(H(c1)) + UA(c1, x, b, a**(2**i), N, zero) + R
p = R + p
p = write_in(1, x) + p
p = def_regs + p
p = get_defs() + p
p = address_qubits(p)
return p
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_occupation_basis():
prog = Program().inst([X(0), X(1), I(2), I(3)])
state = np.zeros(2 ** 4)
state[3] = 1.0
qam = PyQVM(n_qubits=4, quantum_simulator_type=ReferenceWavefunctionSimulator)
qam.execute(prog)
np.testing.assert_allclose(state, qam.wf_simulator.wf)
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 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 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 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 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 test_qc():
from pyquil.api import ForestConnection, QuantumComputer
from pyquil.api._compiler import _extract_attribute_dictionary_from_program
from pyquil.api._qac import AbstractCompiler
from pyquil.device import NxDevice
from pyquil.gates import I
class BasicQVMCompiler(AbstractCompiler):
def quil_to_native_quil(self, program: Program):
return basic_compile(program)
def native_quil_to_executable(self, nq_program: Program):
return PyQuilExecutableResponse(
program=nq_program.out(),
attributes=_extract_attribute_dictionary_from_program(nq_program))
try:
qc = QuantumComputer(
name='testing-qc',
qam=QVM(connection=ForestConnection(), random_seed=52),
device=NxDevice(nx.complete_graph(2)),
compiler=BasicQVMCompiler(),
)
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: {}".format(e))
def test_CCNOT_in_X_basis(qvm):
"""
Testing the definition of Toffoli / CCNOT in the X basis.
"""
# Toffoli truth table
true_truth_table = {(0, 0, 0): (0, 0, 0),
(0, 0, 1): (0, 0, 1),
(0, 1, 0): (0, 1, 0),
(0, 1, 1): (0, 1, 1),
(1, 0, 0): (1, 0, 0),
(1, 0, 1): (1, 0, 1),
(1, 1, 0): (1, 1, 1),
(1, 1, 1): (1, 1, 0)}
CCNOTX = CCNOT_X_basis(0, 1, 2)
for key, value in true_truth_table.items():
state_prep_prog = Program().inst(I(2))
meas_prog = Program()
for qbit_idx, bit in enumerate(key):
if bit == 1:
state_prep_prog += X(qbit_idx)
# Hadamard to get to the X basis
state_prep_prog += H(qbit_idx)
# Hadamard to get back to the Z basis before measurement
meas_prog += H(qbit_idx)
prog=state_prep_prog + CCNOTX + meas_prog
ro = prog.declare('ro', 'BIT', 3)
for q in range(3):
prog += MEASURE(q, ro[q])
exe = qvm.compiler.native_quil_to_executable(prog)
result = qvm.run(exe)
assert tuple(result[0]) == true_truth_table[key]
def estimate_assignment_probs(q, trials, cxn, p0=None):
"""
Estimate the readout assignment probabilities for a given qubit ``q``.
The returned matrix is of the form::
[[p00 p01]
[p10 p11]]
:param int q: The index of the qubit.
:param int trials: The number of samples for each state preparation.
:param Union[QVMConnection,QPUConnection] cxn: The quantum abstract machine to sample from.
:param Program p0: A header program to prepend to the state preparation programs.
:return: The assignment probability matrix
:rtype: np.array
"""
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, 0)), [0], trials))
results_x = np.sum(cxn.run(p0 + Program(X(q), MEASURE(q, 0)), [0], trials))
p00 = 1. - results_i / float(trials)
p11 = results_x / float(trials)
return np.array([[p00, 1 - p11],
[1 - p00, p11]])
def meyer_penny_program():
"""
Returns the program to simulate the Meyer-Penny Game
The full description is available in ../docs/source/exercises.rst
:return: pyQuil Program
"""
prog = pq.Program()
ro = prog.declare("ro", memory_size=2)
picard_register = ro[1]
answer_register = ro[0]
then_branch = pq.Program(X(0))
else_branch = pq.Program(I(0))
# Prepare Qubits in Heads state or superposition, respectively
prog.inst(X(0), H(1))
# Q puts the coin into a superposition
prog.inst(H(0))
# Picard makes a decision and acts accordingly
prog.measure(1, picard_register)
prog.if_then(picard_register, then_branch, else_branch)
# Q undoes his superposition operation
prog.inst(H(0))
# The outcome is recorded into the answer register
prog.measure(0, answer_register)
return prog
def forest():
try:
connection = ForestConnection()
connection._wavefunction(Program(I(0)), 52)
return connection
except (RequestException, UnknownApiError) as e:
return pytest.skip("This test requires a Forest connection: {}".format(e))
def qvm():
try:
qvm = QVMConnection(random_seed=52)
qvm.run(Program(I(0)), [])
return qvm
except (RequestException, UnknownApiError) as e:
return pytest.skip("This test requires QVM connection: {}".format(e))
def compiler(compiler_quantum_processor: CompilerQuantumProcessor,
client_configuration: QCSClientConfiguration):
compiler = QVMCompiler(quantum_processor=compiler_quantum_processor,
timeout=1,
client_configuration=client_configuration)
program = Program(I(0))
compiler.quil_to_native_quil(program)
return compiler
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))
def test_generate_1q_state_tomography_experiment():
qubits = [0]
prog = Program(I(qubits[0]))
one_q_exp = generate_state_tomography_experiment(prog, qubits=qubits)
dimension = 2**len(qubits)
assert [one_q_exp[idx][0].out_operator[qubits[0]] for idx in range(0, dimension ** 2)] == \
['I', 'X', 'Y', 'Z']
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 qvm():
try:
qc = get_qc('9q-square-qvm')
qc.run_and_measure(Program(I(0)), trials=1)
return qc
except RequestException 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 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 benchmarker():
try:
bm = get_benchmarker(timeout=2)
bm.apply_clifford_to_pauli(Program(I(0)), sX(0))
return bm
except (RequestException, TimeoutError) as e:
return pytest.skip("This test requires a running local benchmarker endpoint (ie quilc): {}"
.format(e))
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))
