def NuclearInitializationWithRemoteInitialization(name,
carbon_nr=5,
carbon_init_state='up',
el_RO='positive',
detuning=0.5e3,
el_state=0,
beating_wait_time=1e-6,
free_evolution_time=400e-6 +
np.linspace(0., 6.0e-3, 44),
debug=False):
m = DD.NuclearInitializationWithRemoteInitialization(name)
funcs.prepare(m)
'''Set parameters'''
m.params['C13_MBI_RO_state'] = 0
m.params['C13_MBI_threshold_list'] = [1, 1]
m.params['beating_wait_time'] = beating_wait_time - (
(m.params['C13_MBI_RO_duration'] + m.params['SP_duration_after_C13']) *
1e-6 + 20e-6)
m.params[
'add_wait_gate'] = True #could be removed, does the beating wait gate and ramsey times
m.params['reps_per_ROsequence'] = 250
### Sweep parameters
m.params['Tomography Bases'] = TD.get_tomo_bases(nr_of_qubits=1)
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
# m.params['free_evolution_time'] = free_evolution_time
# m.params['sweep_name'] = 'free_evolution_time'
# m.params['sweep_pts'] = m.params['free_evolution_time']
# m.params['C'+str(carbon_nr)+'_freq_0'] += detuning
# m.params['C'+str(carbon_nr)+'_freq_1'+m.params['electron_transition']] += detuning
m.params['C_RO_phase'] = np.ones(m.params['pts']) * 0
'''Derived and fixed parameters'''
m.params['electron_readout_orientation'] = el_RO
m.params['carbon_nr'] = carbon_nr
m.params['init_state'] = carbon_init_state
m.params['electron_after_init'] = str(el_state)
m.params['Nr_C13_init'] = 2
m.params['Nr_MBE'] = 0
m.params['Nr_parity_msmts'] = 0
funcs.finish(m, upload=True, debug=debug)
def MBE(name,
carbon_list=[1, 5, 2],
carbon_init_list=[2, 5, 1],
carbon_init_states=3 * ['up'],
carbon_init_methods=3 * ['swap'],
carbon_init_thresholds=3 * [0],
number_of_MBE_steps=1,
logic_state='X',
mbe_bases=['Y', 'Y', 'Y'],
MBE_threshold=1,
RO_C=1,
number_of_parity_msmnts=2,
error_on_qubit='all',
el_RO='positive',
debug=False,
error_sign=1,
error_probability_list=np.linspace(0, 1, 3),
parity_orientations=['positive', 'negative']):
m = DD.Three_QB_det_QEC(name)
funcs.prepare(m)
phase_error = error_sign * 2 * np.arcsin(
np.sqrt(error_probability_list)) * 180. / np.pi
if error_on_qubit == 1:
Qe = [1, 0, 0]
elif error_on_qubit == 2:
Qe = [0, 1, 0]
elif error_on_qubit == 3:
Qe = [0, 0, 1]
elif error_on_qubit == 'all':
Qe = [1, 1, 1]
m.params['phase_error_array'] = np.transpose(
[phase_error * Qe[0], phase_error * Qe[1], phase_error * Qe[2]])
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
m.params['Parity_a_RO_orientation'] = parity_orientations[0]
m.params['Parity_b_RO_orientation'] = parity_orientations[1]
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 500
### Carbons to be used
m.params['carbon_list'] = carbon_list
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
'''Select right tomography basis '''
if parity_orientations == ['positive', 'positive']:
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit='',
Flip_axis='',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit='2',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit='3',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit='1',
Flip_axis='Z',
RO_list=logic_state +
'_list')[RO_C]
elif parity_orientations == ['negative', 'negative']:
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit='',
Flip_axis='',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit='2',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit='3',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit='1',
Flip_axis='Z',
RO_list=logic_state +
'_list')[RO_C]
elif parity_orientations == ['positive', 'negative']:
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit='',
Flip_axis='',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit='2',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit='3',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit='1',
Flip_axis='Z',
RO_list=logic_state +
'_list')[RO_C]
elif parity_orientations == ['negative', 'positive']:
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit='',
Flip_axis='',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit='2',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit='3',
Flip_axis='Y',
RO_list=logic_state +
'_list')[RO_C]
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit='1',
Flip_axis='Z',
RO_list=logic_state +
'_list')[RO_C]
###################
### MBE settings ###
####################
m.params['Nr_MBE'] = number_of_MBE_steps
m.params['MBE_bases'] = mbe_bases
m.params['MBE_threshold'] = MBE_threshold
m.params['3qb_logical_state'] = logic_state
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = number_of_parity_msmnts
m.params['Parity_threshold'] = 1
m.params['Parity_a_carbon_list'] = [2, 1]
m.params['Parity_b_carbon_list'] = [5, 1]
m.params['Parity_a_RO_list'] = ['X', 'X']
m.params['Parity_b_RO_list'] = ['X', 'X']
### Derive other parameters
m.params['pts'] = len(error_probability_list)
m.params['sweep_name'] = 'Error Probability'
m.params['sweep_pts'] = error_probability_list
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload=True, debug=debug)
def MBE(name, carbon = 1,
carbon_init_list = [1],
carbon_init_states = ['up'],
carbon_init_methods = ['swap'],
carbon_init_thresholds = [0],
el_RO = 'positive',
debug = False):
m = DD.Two_QB_Probabilistic_MBE(name)
funcs.prepare(m)
m.params['el_after_init'] = '0'
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 1000
### Carbons to be used
m.params['carbon_list'] = [carbon]
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
m.params['Tomography Bases'] = TD.get_tomo_bases(nr_of_qubits = 1)
# m.params['Tomography Bases'] = [['X'],['Y'],['Z']]
# m.params['Tomography Bases'] = [['X'],['Y']]
# m.params['Tomography Bases'] = [['X']]
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
### Derive other parameters
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
### RO params
m.params['electron_readout_orientation'] = el_RO
for BP in m.params['Tomography Bases']:
m.params['sweep_pts'].append(BP[0])
funcs.finish(m, upload =True, debug=debug)
def MBE(name, carbon_list = [1,5,2],
carbon_init_list = [2,5,1],
carbon_init_states = 3*['up'],
carbon_init_methods = 3*['swap'],
carbon_init_thresholds = 3*[0],
number_of_MBE_steps = 1,
logic_state = 'X',
mbe_bases = ['Y','Y','Y'],
MBE_threshold = 1,
RO_C = 1,
number_of_parity_msmnts = 4,
error_on_qubit = 'all',
el_RO = 'positive',
debug = False,
error_sign1 = 1,
error_sign2 = 1,
error_sign3 = 1,
error_probability_list = np.linspace(0,1,3),
parity_orientations = ['positive','negative'],
error_prob_magnitude = '< 0.5',
no_reps = 500):
m = DD.Three_QB_det_rep_QEC(name)
funcs.prepare(m)
### Calculate the new error probability p_e' for splitting up the error in two rounds ###
### for errors < 0.5
if error_prob_magnitude == '< 0.5':
error_probability_list_per_round = (1 - (1 - 2*error_probability_list)**(1/3.))/2.
### for errors > 0.5
# elif error_prob_magnitude == '> 0.5':
# error_probability_list_per_round = 1 - (1 - (1 - 2*error_probability_list)**0.5)/2.
# error_probability_list_per_round = error_probability_list_per_round[::-1]
phase_error_round1 = error_sign1 * 2*np.arcsin(np.sqrt(error_probability_list_per_round))*180./np.pi
phase_error_round2 = error_sign2 * 2*np.arcsin(np.sqrt(error_probability_list_per_round))*180./np.pi
phase_error_round3 = error_sign3 * 2*np.arcsin(np.sqrt(error_probability_list_per_round))*180./np.pi
if error_on_qubit ==1:
Qe = [1,0,0]
elif error_on_qubit ==2:
Qe = [0,1,0]
elif error_on_qubit ==3:
Qe = [0,0,1]
elif error_on_qubit =='all':
Qe = [1,1,1]
m.params['phase_error_array_1'] = np.transpose([phase_error_round1*Qe[0],phase_error_round1*Qe[1],phase_error_round1*Qe[2]])
m.params['phase_error_array_2'] = np.transpose([phase_error_round2*Qe[0],phase_error_round2*Qe[1],phase_error_round2*Qe[2]])
m.params['phase_error_array_3'] = np.transpose([phase_error_round3*Qe[0],phase_error_round3*Qe[1],phase_error_round3*Qe[2]])
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
m.params['Parity_a_RO_orientation'] = parity_orientations[0]
m.params['Parity_b_RO_orientation'] = parity_orientations[1]
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = no_reps
m.params['free_evolution_time_1'] = np.ones(len(phase_error_round1))*0
m.params['free_evolution_time_2'] = np.ones(len(phase_error_round1))*0
### Carbons to be used
m.params['MBE_list'] = carbon_list
m.params['carbon_list'] = carbon_list
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
'''Select right tomography basis '''
if parity_orientations == ['positive','positive']:
m.params['Tomo_Bases_0000'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0001'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0010'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0011'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0100'] = TD.get_tomo_bases(Flip_qubit = '2' , Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0101'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0110'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0111'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1000'] = TD.get_tomo_bases(Flip_qubit = '3' , Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1001'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1010'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1011'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1100'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1101'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1110'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1111'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
# correction on C1 or C2 in second parity A msmt
m.params['phase_correct_list_A00'] = [0 ,0 ] # no error
m.params['phase_correct_list_A01'] = [0 ,0 ] # error on C5, fixed in parity msmt B
m.params['phase_correct_list_A10'] = [180,0 ] # fix error on C2 (first in parity measurment A)
m.params['phase_correct_list_A11'] = [0 ,180] # error on C1 (second in parity measurements A,B)
# correction on C5 in second parity B msmt, 2X implemented because independent of outcome of second parity A
m.params['phase_correct_list_B000'] = [0, 0] # no error
m.params['phase_correct_list_B010'] = [180,0] # fix error on C5 (first in parity measurement B)
m.params['phase_correct_list_B100'] = [0, 0] # error on C2 (already fixed)
m.params['phase_correct_list_B110'] = [0, 0] # error on C1 (already fixed)
m.params['phase_correct_list_B001'] = [0, 0] # no error
m.params['phase_correct_list_B011'] = [180,0] # fix error on C5 (first in parity measurement B)
m.params['phase_correct_list_B101'] = [0, 0] # error on C2 (already fixed)
m.params['phase_correct_list_B111'] = [0, 0] # error on C1 (already fixed)
elif parity_orientations == ['negative','negative']:
m.params['Tomo_Bases_1111'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1110'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1101'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1100'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1011'] = TD.get_tomo_bases(Flip_qubit = '2' , Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1010'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1001'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1000'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0111'] = TD.get_tomo_bases(Flip_qubit = '3' , Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0110'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0101'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0100'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0011'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0010'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0001'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0000'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
# correction on C1 or C2 in second parity A msmt
m.params['phase_correct_list_A11'] = [0 ,0 ] # no error
m.params['phase_correct_list_A10'] = [0 ,0 ] # error on C5, fixed in parity msmt B
m.params['phase_correct_list_A01'] = [180,0 ] # error on C2
m.params['phase_correct_list_A00'] = [0 ,180] # error on C1
# correction on C5 in second parity B msmt, 2X implemented because independent of outcome of second parity A
m.params['phase_correct_list_B110'] = [0,0] # no error
m.params['phase_correct_list_B100'] = [180,0] # error on C5
m.params['phase_correct_list_B010'] = [0,0] # error on C2
m.params['phase_correct_list_B000'] = [0,0] # error on C1
m.params['phase_correct_list_B111'] = [0,0] # no error
m.params['phase_correct_list_B101'] = [180,0] # error on C5
m.params['phase_correct_list_B011'] = [0,0] # error on C2
m.params['phase_correct_list_B001'] = [0,0] # error on C1
elif parity_orientations == ['positive','negative']:
m.params['Tomo_Bases_0101'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0100'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0111'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0110'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0001'] = TD.get_tomo_bases(Flip_qubit = '2' , Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0000'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0011'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0010'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1101'] = TD.get_tomo_bases(Flip_qubit = '3' , Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1100'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1111'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1110'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1001'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1000'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1011'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1010'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
# correction on C1 or C2 in second parity A msmt
m.params['phase_correct_list_A01'] = [0 ,0 ] # no error
m.params['phase_correct_list_A00'] = [0 ,0 ] # error on C5, fixed in parity msmt B
m.params['phase_correct_list_A11'] = [180,0 ] # error on C2
m.params['phase_correct_list_A10'] = [0 ,180] # error on C1
# correction on C5 in second parity B msmt, 2X implemented because independent of outcome of second parity A
m.params['phase_correct_list_B010'] = [0,0] # no error
m.params['phase_correct_list_B000'] = [180,0] # error on C5
m.params['phase_correct_list_B110'] = [0,0] # error on C2
m.params['phase_correct_list_B100'] = [0,0] # error on C1
m.params['phase_correct_list_B011'] = [0,0] # no error
m.params['phase_correct_list_B001'] = [180,0] # error on C5
m.params['phase_correct_list_B111'] = [0,0] # error on C2
m.params['phase_correct_list_B101'] = [0,0] # error on C1
elif parity_orientations == ['negative','positive']:
m.params['Tomo_Bases_1010'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1011'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1000'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1001'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1110'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1111'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1100'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_1101'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0010'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'X', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0011'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0000'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0001'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0110'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0111'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0100'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_0101'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
# correction on C1 or C2 in second parity A msmt
m.params['phase_correct_list_A10'] = [0 ,0 ] # no error
m.params['phase_correct_list_A11'] = [0 ,0 ] # error on C5, fixed in parity msmt B
m.params['phase_correct_list_A00'] = [180,0 ] # error on C2
m.params['phase_correct_list_A01'] = [0 ,180] # error on C1
# correction on C5 in second parity B msmt, 2X implemented because independent of outcome of second parity A
m.params['phase_correct_list_B100'] = [0,0] # no error
m.params['phase_correct_list_B110'] = [180,0] # error on C5
m.params['phase_correct_list_B000'] = [0,0] # error on C2
m.params['phase_correct_list_B010'] = [0,0] # error on C1
m.params['phase_correct_list_B101'] = [0,0] # no error
m.params['phase_correct_list_B111'] = [180,0] # error on C5
m.params['phase_correct_list_B001'] = [0,0] # error on C2
m.params['phase_correct_list_B011'] = [0,0] # error on C1
###################
### MBE settings ###
####################
m.params['Nr_MBE'] = number_of_MBE_steps
m.params['MBE_bases'] = mbe_bases
m.params['MBE_threshold'] = MBE_threshold
m.params['3qb_logical_state'] = logic_state
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = number_of_parity_msmnts
m.params['Parity_threshold'] = 1
m.params['Parity_a_carbon_list'] = [2,1]
m.params['Parity_b_carbon_list'] = [5,1]
m.params['Parity_a_RO_list'] = ['X','X']
m.params['Parity_b_RO_list'] = ['X','X']
### Derive other parameters
m.params['pts'] = len(error_probability_list)
m.params['sweep_name'] = 'Error Probability'
m.params['sweep_pts'] = error_probability_list
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload =True, debug=False)
def MBE_test_msmt(name, carbon_list = [1,5,2],
carbon_init_list = [2,5,1],
carbon_init_states = 3*['up'],
carbon_init_methods = 3*['swap'],
carbon_init_thresholds = 3*[0],
number_of_MBE_steps = 1,
logic_state = 'X',
mbe_bases = ['Y','Y','Y'],
MBE_threshold = 1,
RO_C = 1,
number_of_parity_msmnts = 2,
error_on_qubit = 'all',
el_RO = 'positive',
debug = False,
error_sign1 = 1,
error_sign2 = 1,
error_probability_list = np.linspace(0,1,3),
parity_orientations = ['positive','negative'],
error_prob_magnitude = '< 0.5'):
m = DD.Three_QB_det_QEC(name)
funcs.prepare(m)
### Calculate the new error probability p_e' for splitting up the error in two rounds ###
### for errors < 0.5
if error_prob_magnitude == '< 0.5':
error_probability_list_per_round = [0]#(1 - (1 - 2*error_probability_list)**0.5)/2.
### for errors > 0.5
# elif error_prob_magnitude == '> 0.5':
# error_probability_list_per_round = 1 - (1 - (1 - 2*error_probability_list)**0.5)/2.
# error_probability_list_per_round = error_probability_list_per_round[::-1]
phase_error_round1 = error_sign1 * 2*np.arcsin(np.sqrt(error_probability_list_per_round))*180./np.pi
phase_error_round2 = error_sign2 * 2*np.arcsin(np.sqrt(error_probability_list_per_round))*180./np.pi
if error_on_qubit ==1:
Qe = [1,0,0]
elif error_on_qubit ==2:
Qe = [0,1,0]
elif error_on_qubit ==3:
Qe = [0,0,1]
elif error_on_qubit =='all':
Qe = [1,1,1]
m.params['phase_error_array_1'] = np.transpose([phase_error_round1*Qe[0],phase_error_round1*Qe[1],phase_error_round1*Qe[2]])
m.params['phase_error_array_2'] = np.transpose([phase_error_round2*Qe[0],phase_error_round2*Qe[1],phase_error_round2*Qe[2]])
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
m.params['Parity_a_RO_orientation'] = parity_orientations[0]
m.params['Parity_b_RO_orientation'] = parity_orientations[1]
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 500
m.params['add_wait_gate'] = False
m.params['wait_in_msm1'] = False
m.params['free_evolution_time_1'] = np.ones(len(phase_error_round1))*0
m.params['free_evolution_time_2'] = np.ones(len(phase_error_round1))*0
### Carbons to be used
m.params['MBE_list'] = carbon_list
m.params['carbon_list'] = carbon_list
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
'''Select right tomography basis '''
if parity_orientations == ['positive','positive']:
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
elif parity_orientations == ['negative','negative']:
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
elif parity_orientations == ['positive','negative']:
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
elif parity_orientations == ['negative','positive']:
m.params['Tomo_Bases_10'] = TD.get_tomo_bases(Flip_qubit = '' , Flip_axis = '', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_11'] = TD.get_tomo_bases(Flip_qubit = '2', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_00'] = TD.get_tomo_bases(Flip_qubit = '3', Flip_axis = 'Y', RO_list = logic_state+'_list')[RO_C]
m.params['Tomo_Bases_01'] = TD.get_tomo_bases(Flip_qubit = '1', Flip_axis = 'Z', RO_list = logic_state+'_list')[RO_C]
###################
### MBE settings ###
####################
m.params['Nr_MBE'] = number_of_MBE_steps
m.params['MBE_bases'] = mbe_bases
m.params['MBE_threshold'] = MBE_threshold
m.params['3qb_logical_state'] = logic_state
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = number_of_parity_msmnts
m.params['Parity_threshold'] = 1
m.params['Parity_a_carbon_list'] = [2,1]
m.params['Parity_b_carbon_list'] = [5,1]
m.params['Parity_a_RO_list'] = ['X','X']
m.params['Parity_b_RO_list'] = ['X','X']
### Derive other parameters
m.params['pts'] = len(error_probability_list)
m.params['sweep_name'] = 'Error Probability'
m.params['sweep_pts'] = error_probability_list
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload =True, debug=debug)
def MBE(name,
carbon_list=[1, 5, 2],
carbon_init_list=[2, 5, 1],
carbon_init_states=3 * ['up'],
carbon_init_methods=3 * ['swap'],
carbon_init_thresholds=3 * [0],
number_of_MBE_steps=1,
logic_state='Y',
mbe_bases=['Y', 'Y', 'Y'],
MBE_threshold=1,
number_of_parity_msmnts=0,
parity_msmnts_threshold=1,
RO_C=1,
el_RO='positive',
debug=False,
error_sign=1,
error_on_qubit='all',
do_idle=False,
error_probability_list=np.linspace(0, 1, 3),
Tomo_bases=['Z', '-Y', 'Z']):
m = DD.Three_QB_QEC(name)
funcs.prepare(m)
if do_idle == False:
m.params['add_wait_gate'] = False
else:
m.params['add_wait_gate'] = True
m.params['free_evolution_time'] = (
(2 * m.params['C2_Ren_tau'][0] * m.params['C2_Ren_N'][0] + 2 *
m.params['C1_Ren_tau'][0] * m.params['C1_Ren_N'][0]) # Parity A
+ (2 * m.params['C5_Ren_tau'][0] * m.params['C5_Ren_N'][0] + 2 *
m.params['C1_Ren_tau'][0] * m.params['C1_Ren_N'][0]) # Parity B
+ 2 * 150e-6) * np.ones(
len(error_probability_list)) # 2X RO trigger
phase_error = error_sign * 2 * np.arcsin(
np.sqrt(error_probability_list)) * 180. / np.pi
if error_on_qubit == 1:
Qe = [1, 0, 0]
elif error_on_qubit == 2:
Qe = [0, 1, 0]
elif error_on_qubit == 3:
Qe = [0, 0, 1]
elif error_on_qubit == 'all':
Qe = [1, 1, 1]
m.params['phase_error_array'] = np.transpose(
[phase_error * Qe[0], phase_error * Qe[1], phase_error * Qe[2]])
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 4000
### Carbons to be used
m.params['carbon_list'] = carbon_list
m.params['MBE_list'] = carbon_list
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
'''Select right tomography basis '''
m.params['Tomography Bases'] = TD.get_tomo_bases(Flip_qubit='',
Flip_axis='',
RO_list=logic_state +
'_list')[RO_C]
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = number_of_MBE_steps
m.params['MBE_bases'] = mbe_bases
m.params['MBE_threshold'] = MBE_threshold
m.params['3qb_logical_state'] = logic_state
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = number_of_parity_msmnts
m.params['Parity_threshold'] = parity_msmnts_threshold
### Derive other parameters
m.params['pts'] = len(error_probability_list)
m.params['sweep_name'] = 'Error Probability'
m.params['sweep_pts'] = error_probability_list
### RO params
m.params['electron_readout_orientation'] = el_RO
funcs.finish(m, upload=True, debug=debug)
def uncond_Pi_Sweep(name,
carbon=1,
carbon_init_list=[1],
desired_carbon_init_states=['X'],
el_RO='positive',
debug=False):
m = Uncond_Pi_Sweep(name)
funcs.prepare(m)
carbon_init_methods = []
carbon_init_thresholds = []
carbon_init_states = []
print desired_carbon_init_states
for init_state in desired_carbon_init_states:
if init_state == 'X':
carbon_init_methods.append('MBI')
carbon_init_thresholds.append(1)
carbon_init_states.append('up')
elif init_state == 'mX':
carbon_init_methods.append('MBI')
carbon_init_thresholds.append(1)
carbon_init_states.append('down')
elif init_state == 'Y':
carbon_init_methods.append('MBI_y')
carbon_init_thresholds.append(1)
carbon_init_states.append('up')
elif init_state == 'mY':
carbon_init_methods.append('MBI_y')
carbon_init_thresholds.append(1)
carbon_init_states.append('down')
elif init_state == 'Z':
carbon_init_methods.append('MBI_w_gate')
carbon_init_thresholds.append(1)
carbon_init_states.append('up')
elif init_state == 'mZ':
carbon_init_methods.append('MBI_w_gate')
carbon_init_thresholds.append(1)
carbon_init_states.append('down')
else:
print "Invalid state"
return
m.params['el_after_init'] = '0'
m.params['C13_MBI_threshold_list'] = carbon_init_thresholds
''' set experimental parameters '''
m.params['reps_per_ROsequence'] = 1000
### Carbons to be used
m.params['carbon_list'] = [carbon]
### Carbon Initialization settings
m.params['carbon_init_list'] = carbon_init_list
m.params['init_method_list'] = carbon_init_methods
m.params['init_state_list'] = carbon_init_states
m.params['Nr_C13_init'] = len(carbon_init_list)
##################################
### RO bases (sweep parameter) ###
##################################
m.params['Tomography Bases'] = TD.get_tomo_bases(nr_of_qubits=1)
# m.params['Tomography Bases'] = [['X'],['Y'],['Z']]
# m.params['Tomography Bases'] = [['X'],['Y']]
# m.params['Tomography Bases'] = [['Z']]
####################
### MBE settings ###
####################
m.params['Nr_MBE'] = 0
m.params['MBE_bases'] = []
m.params['MBE_threshold'] = 1
###################################
### Parity measurement settings ###
###################################
m.params['Nr_parity_msmts'] = 0
m.params['Parity_threshold'] = 1
### Derive other parameters
m.params['pts'] = len(m.params['Tomography Bases'])
m.params['sweep_name'] = 'Tomography Bases'
m.params['sweep_pts'] = []
### RO params
m.params['electron_readout_orientation'] = el_RO
for BP in m.params['Tomography Bases']:
m.params['sweep_pts'].append(BP[0])
funcs.finish(m, upload=True, debug=debug)
