# qubit number=4
# total number=31
import pyquil
from pyquil.api import local_forest_runtime, QVMConnection
from pyquil import Program, get_qc
from pyquil.gates import *
import numpy as np
conn = QVMConnection()
def make_circuit()-> Program:
prog = Program() # circuit begin
prog += CNOT(0,3) # number=12
prog += X(3) # number=13
prog += CNOT(0,3) # number=14
prog += Z(3) # number=10
prog += H(1) # number=2
prog += H(2) # number=3
prog += RX(2.708052867394402,1) # number=11
prog += H(3) # number=4
prog += H(0) # number=5
prog += H(1) # number=6
prog += Y(2) # number=16
prog += H(0) # number=28
prog += CZ(1,0) # number=29
prog += H(0) # number=30
prog += H(3) # number=25
def reservoir_compute(sample, reservoir_circuit, qcircuit_callback):
'''
sample: numpy array of floating point data
reservoir_circuit: Program to implement quantum reservoir computer
qcircuit_callback: a callback to generate the input state
initialization circuit
'''
p = qcircuit_callback(sample)
psi = qvm.wavefunction(p + p_reservoir)
probabilities = np.real(psi.amplitudes.conjugate() * psi.amplitudes)
return probabilities
if __name__ == '__main__':
qvm = QVMConnection()
# circuit depth parameter
depth = 8
# initialize repeatable random reservoir
np.random.seed(12939229)
theta_init = get_init_theta(depth)
p_reservoir = output_gates(theta_init, depth)
# load data
train, test = load_mnist_data()
num_train_samples = train[0].shape[0]
num_test_samples = test[0].shape[0]
# for debugging, limit job sizes
import matplotlib.pyplot as plt
from grove.tomography.process_tomography import do_process_tomography
from pyquil.api import CompilerConnection
from pyquil.api import QVMConnection
from pyquil.api import get_devices
from pyquil.gates import *
from pyquil.quil import Program
qvm = QVMConnection()
acorn = get_devices(as_dict=True)['19Q-Acorn']
# QVM with QPU
qpu = QVMConnection()
# noise acorn; qpu = QVMConnection()
#qpu = QPUConnection(acorn)
qubits = [8, 13]
gate = SWAP
gate_str = 'SWAP'
numberSamples = 500
numberSamplesQVM = 1000
def compile_INIT_gate(prog):
compiler = CompilerConnection(acorn)
compiledProg = compiler.compile(prog)
qpuProg = Program()
qpuProg.inst(compiledProg)
def test_estimate_pauli_sum():
"""
Full test of the estimation procedures
"""
quantum_resource = QVMConnection()
# type checks
with pytest.raises(TypeError):
estimate_pauli_sum('5', {
0: 'X',
1: 'Z'
}, Program(), 1.0E-3, quantum_resource)
with pytest.raises(CommutationError):
estimate_pauli_sum([sX(0), sY(0)], {
0: 'X',
1: 'Z'
}, Program(), 1.0E-3, quantum_resource)
with pytest.raises(TypeError):
estimate_pauli_sum(sX(0), {
0: 'X',
1: 'Z'
}, Program(), 1.0E-3, quantum_resource)
# mock out qvm
np.random.seed(87655678)
brv1 = bernoulli(p=0.25)
brv2 = bernoulli(p=0.4)
n = 500
two_qubit_measurements = list(zip(brv1.rvs(size=n), brv2.rvs(size=n)))
pauli_terms = [sZ(0), sZ(1), sZ(0) * sZ(1)]
fakeQVM = Mock(spec=QVMConnection())
fakeQVM.run = Mock(return_value=two_qubit_measurements)
mean, means, cov, estimator_var, shots = estimate_pauli_sum(
pauli_terms, {
0: 'Z',
1: 'Z'
},
Program(),
1.0E-1,
fakeQVM,
symmetrize=False)
parity_results = np.zeros((len(pauli_terms), n))
parity_results[0, :] = [-2 * x[0] + 1 for x in two_qubit_measurements]
parity_results[1, :] = [-2 * x[1] + 1 for x in two_qubit_measurements]
parity_results[2, :] = [
-2 * (sum(x) % 2) + 1 for x in two_qubit_measurements
]
assert np.allclose(np.cov(parity_results, ddof=1), cov)
assert np.isclose(np.sum(np.mean(parity_results, axis=1)), mean)
assert np.allclose(np.mean(parity_results, axis=1), means)
assert np.isclose(shots, n)
variance_to_beat = np.sum(cov) / (n - 1)
assert np.isclose(variance_to_beat, estimator_var)
# Double the shots by ever so slightly decreasing variance bound
double_two_q_measurements = two_qubit_measurements + two_qubit_measurements
mean, means, cov, estimator_var, shots = estimate_pauli_sum(
pauli_terms, {
0: 'Z',
1: 'Z'
},
Program(),
variance_to_beat - 1.0E-8,
fakeQVM,
symmetrize=False)
parity_results = np.zeros((len(pauli_terms), 2 * n))
parity_results[0, :] = [-2 * x[0] + 1 for x in double_two_q_measurements]
parity_results[1, :] = [-2 * x[1] + 1 for x in double_two_q_measurements]
parity_results[2, :] = [
-2 * (sum(x) % 2) + 1 for x in double_two_q_measurements
]
assert np.allclose(np.cov(parity_results, ddof=1), cov)
assert np.isclose(np.sum(np.mean(parity_results, axis=1)), mean)
assert np.allclose(np.mean(parity_results, axis=1), means)
assert np.isclose(shots, 2 * n)
assert np.isclose(np.sum(cov) / (2 * n - 1), estimator_var)
def without_error(n, s, runs):
""" runs grover on 2^n qubits without error simulation """
qvm = QVMConnection(use_queue=False) # put in queue in case too long
p = grover(n, s) # stores grover program
result = qvm.run(p, list(range(n)), trials=runs) # stores result
print(accuracy(result, s)) # prints accuracy rate
def test():
qvm = QVMConnection()
p = Program(X(1), H(0), CNOT(0, 1))
wf = qvm.wavefunction(p)
wfo = str(wf)
output.writetooutput()
def main():
agave = get_devices(as_dict=True)['8Q-Agave']
compiler = CompilerConnection(agave)
qvm = QVMConnection() # Perfect QVM
qvm_noisy = QVMConnection(agave) # Simulate Noise
qpu = QPUConnection(agave) # Physical QPU
print("Timestamp,"
"Singlet (Wavefunction), Triplet (Wavefunction), "
"Singlet (QVM), Triplet (QVM),"
"Singlet Mean (QVM Noise), Singlet Std (QVM Noise), "
"Triplet Mean (QVM Noise), Triplet Std (QVM Noise),"
"00 Mean (QVM Noise), 00 Std (QVM Noise),"
"11 Mean (QVM Noise), 11 Std (QVM Noise),"
"Singlet Mean (QPU), Singlet Std (QPU),"
"Triplet Mean (QPU), Triplet Std (QPU),"
"00 Mean (QPU), 00 Std (QPU),"
"11 Mean (QPU), 1 Std (QPU)")
# Rotation
fp_raw = open("output.txt", "w")
for t in range(0, 30): # ns
# for t in np.arange(0.0, 30.0, 0.1): # ns
p = create_singlet_state()
add_switch_to_singlet_triplet_basis_gate_to_program(p)
w_larmor = 0.46 # 4.6e8 1/s as determined in the experiment
p.inst(PHASE(w_larmor * t, 0))
p.inst(("SWITCH_TO_SINGLET_TRIPLET_BASIS", 0, 1))
wavefunction = qvm.wavefunction(p)
probs = wavefunction.get_outcome_probs()
p.measure(0, 0)
p.measure(1, 1)
# Run the code on a perfect QVM (no noise)
data = qvm.run(p, trials=1024)
# simulate physical noise on QVM
singlet_noisy = []
triplet_noisy = []
state11_noisy = []
state00_noisy = []
for i in range(0, 3):
data_noisy = qvm_noisy.run(p, trials=1000)
noisy_data_distr = distribution(data_noisy)
singlet_noisy.append(noisy_data_distr[(1, 0)])
triplet_noisy.append(noisy_data_distr[(0, 1)])
state11_noisy.append(noisy_data_distr[(1, 1)])
state00_noisy.append(noisy_data_distr[(0, 0)])
# Run the code on QPU
singlet_qpu = []
triplet_qpu = []
state11_qpu = []
state00_qpu = []
# Suppress print statements
_old_stdout = sys.stdout
for i in range(0, 9):
with open(os.devnull, 'w') as fp:
sys.stdout = fp
data_qpu = qpu.run(p, trials=1024)
qpu_data_distr = distribution(data_qpu)
singlet_qpu.append(qpu_data_distr[(1, 0)])
triplet_qpu.append(qpu_data_distr[(0, 1)])
state11_qpu.append(qpu_data_distr[(1, 1)])
state00_qpu.append(qpu_data_distr[(0, 0)])
sys.stdout = _old_stdout
# print('compiled quil', job.compiled_quil())
# print('gate volume', job.gate_volume())
# print('gate depth', job.gate_depth())
# print('topological swaps', job.topological_swaps())
# print('program fidelity', job.program_fidelity())
# print('multiqubit gate depth', job.multiqubit_gate_depth())
# Note the order of qubit in Rigetti
# http://pyquil.readthedocs.io/en/latest/qvm.html#multi-qubit-basis-enumeration
# (1, 0) is singlet, but in string notation it is reversed ('01'), because
#
# "The Rigetti QVM enumerates bitstrings such that qubit 0 is the least significant bit (LSB)
# and therefore on the right end of a bitstring"
#
print("%s, Noise, Singlet, %s" % (t, singlet_noisy), file=fp_raw)
print("%s, Noise, Triplet, %s" % (t, triplet_noisy), file=fp_raw)
print("%s, Noise, 00, %s" % (t, state00_noisy), file=fp_raw)
print("%s, Noise, 11, %s" % (t, state11_noisy), file=fp_raw)
print("%s, QPU, Singlet, %s" % (t, singlet_qpu), file=fp_raw)
print("%s, QPU, Triplet, %s" % (t, triplet_qpu), file=fp_raw)
print("%s, QPU, 00, %s" % (t, state00_qpu), file=fp_raw)
print("%s, QPU, 11, %s" % (t, state11_qpu), file=fp_raw)
print(
"%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s"
% (
t,
probs['01'],
probs['10'],
distribution(data).get((1, 0), 0),
distribution(data).get((0, 1), 0),
np.mean(singlet_noisy),
np.std(singlet_noisy),
np.mean(triplet_noisy),
np.std(triplet_noisy),
np.mean(state00_noisy),
np.std(state00_noisy),
np.mean(state11_noisy),
np.std(state11_noisy),
np.mean(singlet_qpu),
np.std(singlet_qpu),
np.mean(triplet_qpu),
np.std(triplet_qpu),
np.mean(state00_qpu),
np.std(state00_qpu),
np.mean(state11_qpu),
np.std(state11_qpu),
))
import pytest
from mock import patch
from pyquil.api import QVMConnection, QPUConnection, CompilerConnection
from pyquil.api._base_connection import validate_noise_probabilities, validate_run_items
from pyquil.api.qpu import append_measures_to_program
from pyquil.quil import Program
from pyquil.gates import CNOT, H, MEASURE
from pyquil.device import ISA
BELL_STATE = Program(H(0), CNOT(0, 1))
BELL_STATE_MEASURE = Program(H(0), CNOT(0, 1), MEASURE(0, 0), MEASURE(1, 1))
DUMMY_ISA_DICT = {"1Q": {"0": {}, "1": {}}, "2Q": {"0-1": {}}}
DUMMY_ISA = ISA.from_dict(DUMMY_ISA_DICT)
qvm = QVMConnection(api_key='api_key', user_id='user_id')
async_qvm = QVMConnection(api_key='api_key', user_id='user_id', use_queue=True)
compiler = CompilerConnection(isa_source=DUMMY_ISA,
api_key='api_key',
user_id='user_id')
async_compiler = CompilerConnection(isa_source=DUMMY_ISA,
api_key='api_key',
user_id='user_id',
use_queue=True)
def test_sync_run():
def mock_response(request, context):
assert json.loads(request.text) == {
"type": "multishot",
"addresses": [0, 1],
