def circuit_function(q_t1=3000, q_t2=1500, error=0.01, init_state=''):
c = Circuit(title='default')
subc = Circuit(title='default')
subc.add_qubit('q0', q_t1, q_t2)
subc.add_qubit('q1', q_t1, q_t2)
subc.add_gate(prep_z('q0', time=0))
subc.add_gate(prep_z('q1', time=0))
subc.add_gate(h('q0', time=20))
subc.add_gate(cnot('q0', 'q1', time=40))
subc.add_gate(
measure('q0',
time=60,
sampler=uniform_noisy_sampler(readout_error=0.03, seed=42)))
subc.add_gate(
measure('q1',
time=80,
sampler=uniform_noisy_sampler(readout_error=0.03, seed=42)))
subc.add_gate(
measure('q0',
time=100,
sampler=uniform_noisy_sampler(readout_error=0.03, seed=42)))
subc.add_gate(
measure('q1',
time=100,
sampler=uniform_noisy_sampler(readout_error=0.03, seed=42)))
c.add_subcircuit(subc)
subc = Circuit(title='display_bits')
subc.add_qubit('q0', q_t1, q_t2)
subc.add_qubit('q1', q_t1, q_t2)
c.add_subcircuit(subc)
return c
def test_noisy_measurement_sampler():
c = circuit.Circuit()
c.add_qubit("A", 0, 0)
c.add_hadamard("A", 1)
sampler = circuit.uniform_noisy_sampler(seed=42, readout_error=0.1)
m1 = c.add_measurement("A", time=2, sampler=sampler)
sdm = sparsedm.SparseDM("A")
true_state = []
for _ in range(20):
c.apply_to(sdm)
true_state.append(sdm.classical['A'])
# these samples assume a certain seed (=42)
assert m1.measurements == [0, 1, 0, 0, 1, 0,
1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1]
assert true_state != m1.measurements
assert true_state == [0, 1, 0, 0, 1, 0, 1,
0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1]
# we have two measurement errors
mprob = 0.9**18 * 0.1**2
assert np.allclose(sdm.classical_probability, mprob)
# and each measurement has outcome 1/2
totprob = mprob * 0.5**20
assert np.allclose(sdm.trace(), totprob)
def test_uniform_noisy_sampler(self):
with patch("numpy.random.RandomState") as rsclass:
rs = MagicMock()
rsclass.return_value = rs
rs.random_sample = MagicMock(return_value=0.5)
s = circuit.uniform_noisy_sampler(0.4, seed=42)
next(s)
rsclass.assert_called_once_with(seed=42)
# no readout error
dec, proj, prob = s.send((0.2, 0.8))
assert (proj, dec, prob) == (1, 1, 0.6)
dec, proj, prob = s.send((0.9, 0.1))
assert (proj, dec, prob) == (0, 0, 0.6)
s = circuit.uniform_noisy_sampler(0.7, seed=42)
next(s)
dec, proj, prob = s.send((0.2, 0.8))
assert (proj, dec, prob) == (1, 0, 0.7)
dec, proj, prob = s.send((0.9, 0.1))
assert (proj, dec, prob) == (0, 1, 0.7)
def load(self, filename, seed=None, state=None):
with open(filename, 'r') as infile:
setup_load_format = json.load(infile)
self.update_rules = setup_load_format['update_rules']
self.qubit_dic = setup_load_format['qubit_dic']
# Currently assumes each qubit uses the same
# uniform_noisy_sampler - this needs fixing
if seed is None and state is None:
raise ValueError('''
We require either a numpy.random.RandomState
or a non-null seed for a setup.''')
readout_error = list(self.qubit_dic.values())[0]['readout_error']
sampler = uniform_noisy_sampler(seed=seed,
state=state,
readout_error=readout_error)
for qb_params in self.qubit_dic.values():
qb_params['sampler'] = sampler
self.gate_set = {
tuple(gate['key']): gate['val']
for gate in setup_load_format['gate_set']
}
for gate in self.gate_set.values():
if 'sampler' in gate[0] and gate[0]['sampler'] is True:
gate[0]['sampler'] = sampler
gd = GateData()
self.gate_dic = {
key: gd.available_gate_dic[val]
for key, val in setup_load_format['gate_dic'].items()
}
def get_qubit(noise_flag=True,
t1=np.inf,
t2=100000,
dephasing_axis=1e-5,
dephasing_angle=1e-5,
dephasing=1e-5,
p_exc_init=0,
p_dec_init=0,
p_exc_fin=0,
p_dec_fin=0,
dephase_var=1e-2 / (2 * pi),
msmt_time=3000,
interval_time=1000,
oneq_gate_time=100,
CZ_gate_time=40,
reset_time=100,
sampler=None,
seed=None,
readout_error=0.02,
static_flux_std=None,
**kwargs):
'''
The dictionary for parameters of the DiCarlo qubits, with standard
parameters pre-set.
This is a bit messy right now, but has the advantage of telling
the user which parameters they can set. Not sure how to improve
over this.
'''
if sampler is None:
if noise_flag is True:
sampler = uniform_noisy_sampler(seed=seed,
readout_error=readout_error)
else:
sampler = uniform_sampler(seed=seed)
if static_flux_std is not None:
quasistatic_flux = static_flux_std * np.random.randn()
else:
quasistatic_flux = None
if noise_flag is True:
param_dic = {
't1': t1,
't2': t2,
'dephasing_axis': dephasing_axis,
'dephasing': dephasing,
'dephasing_angle': dephasing_angle,
'dephase_var': dephase_var,
'p_exc_init': p_exc_init,
'p_dec_init': p_dec_init,
'p_exc_fin': p_exc_fin,
'p_dec_fin': p_dec_fin,
'msmt_time': msmt_time,
'interval_time': interval_time,
'oneq_gate_time': oneq_gate_time,
'CZ_gate_time': CZ_gate_time,
'ISwap_gate_time': CZ_gate_time * np.sqrt(2),
'reset_time': reset_time,
'photons': photons,
'alpha0': alpha0,
'kappa': kappa,
'chi': chi,
'quasistatic_flux': quasistatic_flux,
'high_frequency': high_frequency,
'sampler': sampler
}
else:
param_dic = {
't1': np.inf,
't2': np.inf,
'dephasing_axis': 0,
'dephasing': 0,
'dephasing_angle': 0,
'dephase_var': 0,
'p_exc_init': 0,
'p_dec_init': 0,
'p_exc_fin': 0,
'p_dec_fin': 0,
'msmt_time': msmt_time,
'interval_time': interval_time,
'CZ_gate_time': CZ_gate_time,
'ISwap_gate_time': CZ_gate_time * np.sqrt(2),
'reset_time': reset_time,
'photons': False,
'quasistatic_flux': None,
'high_frequency': False,
'sampler': sampler
}
for key, val in kwargs.items():
param_dic[key] = val
return param_dic
def get_qubit(noise_flag=True,
scale=1,
t1=30000,
t2=30000,
dephasing_axis=1e-4,
dephasing_angle=5e-4,
dephasing=5e-4,
p_exc_init=0.0,
p_dec_init=0.005,
p_exc_fin=0.0,
p_dec_fin=0.015,
residual_excitations=0.01,
photons=False,
alpha0=4,
kappa=1 / 250,
chi=1.3 * 1e-3,
static_flux_std=None,
high_frequency=False,
dephase_var=1e-2/(2*pi),
msmt_time=600,
interval_time=150,
oneq_gate_time=20,
CZ_gate_time=40,
reset_time=500,
state=None,
sampler=None,
readout_error=0.005,
**kwargs):
"""
The dictionary for parameters of the DiCarlo qubits, with standard
parameters pre-set.
This is a bit messy right now, but has the advantage of telling
the user which parameters they can set. Not sure how to improve
over this.
"""
if sampler is None:
if noise_flag is True:
sampler = uniform_noisy_sampler(state=state,
readout_error=readout_error)
else:
readout_error = 0
sampler = uniform_sampler(state=state)
if static_flux_std is not None:
quasistatic_flux = static_flux_std * np.random.randn()
else:
quasistatic_flux = None
if noise_flag is True:
param_dic = {
't1': t1/scale,
't2': t2/scale,
'dephasing_axis': dephasing_axis*scale,
'dephasing': dephasing*scale,
'dephasing_angle': dephasing_angle*scale,
'dephase_var': dephase_var*scale,
'p_exc_init': p_exc_init*scale,
'p_dec_init': p_dec_init*scale,
'p_exc_fin': p_exc_fin*scale,
'p_dec_fin': p_dec_fin*scale,
'residual_excitations': residual_excitations*scale,
'msmt_time': msmt_time,
'interval_time': interval_time,
'oneq_gate_time': oneq_gate_time,
'CZ_gate_time': CZ_gate_time,
'ISwap_gate_time': CZ_gate_time*np.sqrt(2),
'reset_time': reset_time,
'photons': photons,
'alpha0': alpha0,
'kappa': kappa,
'chi': chi,
'quasistatic_flux': quasistatic_flux,
'high_frequency': high_frequency,
'sampler': sampler,
'readout_error': readout_error,
}
else:
param_dic = {
't1': np.inf,
't2': np.inf,
'dephasing_axis': 0,
'dephasing': 0,
'dephasing_angle': 0,
'dephase_var': 0,
'p_exc_init': 0,
'p_dec_init': 0,
'p_exc_fin': 0,
'p_dec_fin': 0,
'residual_excitations': 0,
'msmt_time': msmt_time,
'interval_time': interval_time,
'oneq_gate_time': oneq_gate_time,
'CZ_gate_time': CZ_gate_time,
'ISwap_gate_time': CZ_gate_time*np.sqrt(2),
'reset_time': reset_time,
'photons': False,
'quasistatic_flux': None,
'high_frequency': False,
'sampler': sampler,
'readout_error': 0,
}
for key, val in kwargs.items():
param_dic[key] = val
return param_dic
def circuit_function(q_t1=3000, q_t2=1500, error=0.01, init_state=''):
c = Circuit(title='default')
c.add_gate(ResetGate('q0', time=1, state=int(init_state[0])))
c.add_gate(ResetGate('q1', time=1, state=int(init_state[1])))
c.add_gate(ResetGate('q2', time=1, state=int(init_state[2])))
c.add_gate(ResetGate('q3', time=1, state=int(init_state[3])))
c.add_gate(ResetGate('q4', time=1, state=int(init_state[4])))
c.add_gate(ResetGate('q5', time=1, state=int(init_state[5])))
c.add_gate(ResetGate('q6', time=1, state=int(init_state[6])))
c.add_gate(ResetGate('q7', time=1, state=int(init_state[7])))
c.add_gate(ResetGate('q8', time=1, state=int(init_state[8])))
c.add_qubit('q0', q_t1, q_t2)
c.add_qubit('q1', q_t1, q_t2)
c.add_qubit('q2', q_t1, q_t2)
c.add_qubit('q3', q_t1, q_t2)
c.add_qubit('q4', q_t1, q_t2)
c.add_qubit('q5', q_t1, q_t2)
c.add_qubit('q6', q_t1, q_t2)
c.add_qubit('q7', q_t1, q_t2)
c.add_qubit('q8', q_t1, q_t2)
subc = Circuit(title='default')
subc.add_qubit('q0', q_t1, q_t2)
subc.add_qubit('q1', q_t1, q_t2)
subc.add_qubit('q2', q_t1, q_t2)
subc.add_qubit('q3', q_t1, q_t2)
subc.add_qubit('q4', q_t1, q_t2)
subc.add_qubit('q5', q_t1, q_t2)
subc.add_qubit('q6', q_t1, q_t2)
subc.add_qubit('q7', q_t1, q_t2)
subc.add_qubit('q8', q_t1, q_t2)
c.add_subcircuit(
subc, name_map=['q0', 'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8'])
subc = Circuit(title='init')
subc.add_qubit('q0', q_t1, q_t2)
subc.add_qubit('q1', q_t1, q_t2)
subc.add_qubit('q2', q_t1, q_t2)
subc.add_qubit('q3', q_t1, q_t2)
subc.add_qubit('q4', q_t1, q_t2)
subc.add_qubit('q5', q_t1, q_t2)
subc.add_qubit('q6', q_t1, q_t2)
subc.add_qubit('q7', q_t1, q_t2)
subc.add_qubit('q8', q_t1, q_t2)
subc.add_gate(x('q4', time=20))
subc.add_gate(h('q0', time=40))
subc.add_gate(h('q1', time=40))
subc.add_gate(h('q2', time=40))
subc.add_gate(h('q3', time=40))
subc.add_gate(h('q4', time=40))
c.add_subcircuit(
subc, name_map=['q0', 'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8'])
subc = Circuit(title='grover')
subc.add_qubit('q0', q_t1, q_t2)
subc.add_qubit('q1', q_t1, q_t2)
subc.add_qubit('q2', q_t1, q_t2)
subc.add_qubit('q3', q_t1, q_t2)
subc.add_qubit('q4', q_t1, q_t2)
subc.add_qubit('q5', q_t1, q_t2)
subc.add_qubit('q6', q_t1, q_t2)
subc.add_qubit('q7', q_t1, q_t2)
subc.add_qubit('q8', q_t1, q_t2)
subc.add_gate(x('q2', time=60))
subc.add_gate(cnot('q8', 'q4', time=160))
subc.add_gate(x('q2', time=260))
subc.add_gate(h('q0', time=280))
subc.add_gate(h('q1', time=280))
subc.add_gate(h('q2', time=280))
subc.add_gate(h('q3', time=280))
subc.add_gate(x('q0', time=300))
subc.add_gate(x('q1', time=300))
subc.add_gate(x('q2', time=300))
subc.add_gate(x('q3', time=300))
subc.add_gate(h('q3', time=320))
subc.add_gate(cnot('q7', 'q3', time=400))
subc.add_gate(h('q3', time=480))
subc.add_gate(x('q0', time=500))
subc.add_gate(x('q1', time=500))
subc.add_gate(x('q2', time=500))
subc.add_gate(x('q3', time=500))
subc.add_gate(h('q0', time=520))
subc.add_gate(h('q1', time=520))
subc.add_gate(h('q2', time=520))
subc.add_gate(h('q3', time=520))
c.add_subcircuit(
subc, name_map=['q0', 'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8'])
subc = Circuit(title='final_measurement')
subc.add_qubit('q0', q_t1, q_t2)
subc.add_qubit('q1', q_t1, q_t2)
subc.add_qubit('q2', q_t1, q_t2)
subc.add_qubit('q3', q_t1, q_t2)
subc.add_qubit('q4', q_t1, q_t2)
subc.add_qubit('q5', q_t1, q_t2)
subc.add_qubit('q6', q_t1, q_t2)
subc.add_qubit('q7', q_t1, q_t2)
subc.add_qubit('q8', q_t1, q_t2)
subc.add_gate(h('q4', time=560))
subc.add_gate(
measure('q4',
time=580,
sampler=uniform_noisy_sampler(readout_error=0.03, seed=42)))
c.add_subcircuit(
subc, name_map=['q0', 'q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8'])
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m0')
c.add_measurement('q0', time=600, output_bit='m0', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m1')
c.add_measurement('q1', time=600, output_bit='m1', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m2')
c.add_measurement('q2', time=600, output_bit='m2', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m3')
c.add_measurement('q3', time=600, output_bit='m3', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m4')
c.add_measurement('q4', time=600, output_bit='m4', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m5')
c.add_measurement('q5', time=600, output_bit='m5', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m6')
c.add_measurement('q6', time=600, output_bit='m6', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m7')
c.add_measurement('q7', time=600, output_bit='m7', sampler=sampler)
sampler = uniform_noisy_sampler(readout_error=0.03, seed=42)
c.add_qubit('m8')
c.add_measurement('q8', time=600, output_bit='m8', sampler=sampler)
return c
