def test_two_qubit_randomized_benchmarking_sequence(self): """ """ seeds = [0, 100, 200, 300, 400] net_cliffs = np.arange(len(seeds)) for seed, net_cl in zip(seeds, net_cliffs): rb.randomized_benchmarking_sequence( n_cl=20, desired_net_cl=0, number_of_qubits=2, seed=0)
def test_seed_reproduces(self): rb_seq_a = rb.randomized_benchmarking_sequence(500, seed=5) rb_seq_b = rb.randomized_benchmarking_sequence(500, seed=None) rb_seq_c = rb.randomized_benchmarking_sequence(500, seed=5) rb_seq_d = rb.randomized_benchmarking_sequence(500, seed=None) self.assertTrue((rb_seq_a == rb_seq_c).all()) self.assertTrue((rb_seq_a != rb_seq_b).any()) self.assertTrue((rb_seq_c != rb_seq_b).any()) self.assertTrue((rb_seq_b != rb_seq_d).any())
def test_seed_reproduces(self): rb_seq_a = rb.randomized_benchmarking_sequence(500, seed=5) rb_seq_b = rb.randomized_benchmarking_sequence(500, seed=None) rb_seq_c = rb.randomized_benchmarking_sequence(500, seed=5) rb_seq_d = rb.randomized_benchmarking_sequence(500, seed=None) self.assertTrue((rb_seq_a == rb_seq_c).all()) self.assertTrue((rb_seq_a != rb_seq_b).any) self.assertTrue((rb_seq_c != rb_seq_b).any) self.assertTrue((rb_seq_b != rb_seq_d).any)
def test_interleaved_randomized_benchmarking_sequence_1Q(self): seeds = [0, 100, 200, 300, 400] net_cliffs = np.arange(len(seeds)) for seed, net_cl in zip(seeds, net_cliffs): intl_cliffords = rb.randomized_benchmarking_sequence( n_cl=20, desired_net_cl=0, number_of_qubits=1, seed=0, interleaving_cl=0) cliffords = rb.randomized_benchmarking_sequence( n_cl=20, desired_net_cl=0, seed=0) new_cliff = np.empty(cliffords.size*2-1, dtype=int) new_cliff[0::2] = cliffords new_cliff[1::2] = 0 assert_array_equal(intl_cliffords, new_cliff)
def randomized_benchmarking(qubit_idx: int, platf_cfg: str, nr_cliffords, nr_seeds: int, net_clifford: int=0, restless: bool=False, program_name: str='randomized_benchmarking', cal_points: bool=True, double_curves: bool=False): ''' Input pars: qubit_idx: int specifying the target qubit (starting at 0) platf_cfg: filename of the platform config file nr_cliffords: list nr_cliffords for which to generate RB seqs nr_seeds: int nr_seeds for which to generate RB seqs net_clifford: int index of net clifford the sequence should perform 0 -> Idx 3 -> rx180 restless: bool, does not initialize if restless is True program_name: some string that can be used as a label. cal_points: bool whether to replace the last two elements with calibration points, set to False if you want to measure a single element (for e.g. optimization) double_curves: Alternates between net clifford 0 and 3 Returns: p: OpenQL Program object generates a program for single qubit Clifford based randomized benchmarking. ''' net_cliffords = [0, 3] # Exists purely for the double curves mode p = oqh.create_program(program_name, platf_cfg) i = 0 for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): k = oqh.create_kernel('RB_{}Cl_s{}'.format(n_cl, seed), p) if not restless: k.prepz(qubit_idx) if cal_points and (j == (len(nr_cliffords)-4) or j == (len(nr_cliffords)-3)): k.measure(qubit_idx) elif cal_points and (j == (len(nr_cliffords)-2) or j == (len(nr_cliffords)-1)): k.x(qubit_idx) k.measure(qubit_idx) else: if double_curves: net_clifford = net_cliffords[i % 2] i += 1 cl_seq = rb.randomized_benchmarking_sequence( n_cl, desired_net_cl=net_clifford) # pulse_keys = rb.decompose_clifford_seq(cl_seq) for cl in cl_seq: k.gate('cl_{}'.format(cl), [qubit_idx]) k.measure(qubit_idx) p.add_kernel(k) p = oqh.compile(p) return p
def prepare(self, upload_tek_seq=True, **kw): self.AWG.stop() n_cls = self.nr_cliffords time_tape = [] pulse_length = self.LutMan.gauss_width.get()*4 for seed in range(self.nr_seeds): for n_cl in n_cls: cliffords = rb.randomized_benchmarking_sequence(n_cl) cl_tape = rb.convert_clifford_sequence_to_tape( cliffords, self.LutMan.lut_mapping.get()) for i, tape_elt in enumerate(cl_tape): if i == 0: # wait_time is in ns wait_time = (self.max_seq_duration*1e9 - (len(cl_tape)-1)*self.pulse_delay_ns - pulse_length) else: wait_time = self.pulse_delay_ns - pulse_length end_of_marker = (i == (len(cl_tape)-1)) entry = self.CBox.create_timing_tape_entry( wait_time, tape_elt, end_of_marker, prepend_elt=0) time_tape.extend(entry) for cal_pt in self.cal_points: wait_time = self.max_seq_duration*1e9 - pulse_length time_tape.extend(self.CBox.create_timing_tape_entry( wait_time, cal_pt, True, prepend_elt=0)) # print('Total tape length', len(time_tape)) for awg in range(3): self.CBox.set('AWG{}_mode'.format(awg), 'Segmented') self.CBox.set_segmented_tape(awg, time_tape) self.CBox.restart_awg_tape(awg) if upload_tek_seq: self.upload_tek_seq()
def test_single_qubit_randomized_benchmarking_sequence(self): seeds = [0, 100, 200, 300, 400] net_cliffs = np.arange(len(seeds)) for seed, net_cl in zip(seeds, net_cliffs): cliffords_single_qubit_class = rb.randomized_benchmarking_sequence( n_cl=20, desired_net_cl=0, number_of_qubits=1, seed=0) cliffords = rb.randomized_benchmarking_sequence_old( n_cl=20, desired_net_cl=0, seed=0) assert_array_equal(cliffords_single_qubit_class, cliffords)
def get_resetless_rb_detector(self, nr_cliff, starting_seed=1, nr_seeds='max', pulse_p_elt='min', MC=None, upload=True): if MC is None: MC = self.MC if pulse_p_elt == 'min': safety_factor = 5 if nr_cliff < 8 else 3 pulse_p_elt = int(safety_factor*nr_cliff) if nr_seeds == 'max': nr_seeds = 29184//pulse_p_elt if nr_seeds*pulse_p_elt > 29184: raise ValueError( 'Too many pulses ({}), {} seeds, {} pulse_p_elt'.format( nr_seeds*pulse_p_elt, nr_seeds, pulse_p_elt)) resetless_interval = ( np.round(pulse_p_elt*self.pulse_delay.get()*1e6)+2.5)*1e-6 combined_tape = [] for i in range(nr_seeds): if starting_seed is not None: seed = starting_seed*1000*i else: seed = None rb_seq = rb.randomized_benchmarking_sequence(nr_cliff, desired_net_cl=3, seed=seed) tape = rb.convert_clifford_sequence_to_tape( rb_seq, self.LutMan.lut_mapping.get()) if len(tape) > pulse_p_elt: raise ValueError( 'Too many pulses ({}), {} pulse_p_elt'.format( len(tape), pulse_p_elt)) combined_tape += [0]*(pulse_p_elt-len(tape))+tape # Rename IF in awg_swf_resetless tape s = awg_swf.Resetless_tape( n_pulses=pulse_p_elt, tape=combined_tape, IF=self.f_RO_mod.get(), pulse_delay=self.pulse_delay.get(), resetless_interval=resetless_interval, RO_pulse_delay=self.RO_pulse_delay.get(), RO_pulse_length=self.RO_pulse_length.get(), RO_trigger_delay=self.RO_acq_marker_delay.get(), AWG=self.AWG, CBox=self.CBox, upload=upload) d = cdet.CBox_trace_error_fraction_detector( 'Resetless rb det', MC=MC, AWG=self.AWG, CBox=self.CBox, sequence_swf=s, threshold=self.RO_threshold.get(), save_raw_trace=False) return d
def get_resetless_rb_detector(self, nr_cliff, starting_seed=1, nr_seeds='max', pulse_p_elt='min', MC=None, upload=True): if MC is None: MC = self.MC if pulse_p_elt == 'min': safety_factor = 5 if nr_cliff < 8 else 3 pulse_p_elt = int(safety_factor*nr_cliff) if nr_seeds == 'max': nr_seeds = 29184//pulse_p_elt if nr_seeds*pulse_p_elt > 29184: raise ValueError( 'Too many pulses ({}), {} seeds, {} pulse_p_elt'.format( nr_seeds*pulse_p_elt, nr_seeds, pulse_p_elt)) resetless_interval = ( np.round(pulse_p_elt*self.pulse_delay.get()*1e6)+2.5)*1e-6 combined_tape = [] for i in range(nr_seeds): if starting_seed is not None: seed = starting_seed*1000*i else: seed = None rb_seq = rb.randomized_benchmarking_sequence(nr_cliff, desired_net_cl=3, seed=seed) tape = rb.convert_clifford_sequence_to_tape( rb_seq, self.LutMan.lut_mapping.get()) if len(tape) > pulse_p_elt: raise ValueError( 'Too many pulses ({}), {} pulse_p_elt'.format( len(tape), pulse_p_elt)) combined_tape += [0]*(pulse_p_elt-len(tape))+tape # Rename IF in awg_swf_resetless tape s = awg_swf.Resetless_tape( n_pulses=pulse_p_elt, tape=combined_tape, IF=self.f_RO_mod.get(), pulse_delay=self.pulse_delay.get(), resetless_interval=resetless_interval, RO_pulse_delay=self.RO_pulse_delay.get(), RO_pulse_length=self.RO_pulse_length.get(), RO_trigger_delay=self.RO_acq_marker_delay.get(), AWG=self.AWG, CBox=self.CBox, upload=upload) d = cdet.CBox_trace_error_fraction_detector( 'Resetless rb det', MC=MC, AWG=self.AWG, CBox=self.CBox, sequence_swf=s, threshold=self.RO_threshold.get(), save_raw_trace=False) return d
def randomized_benchmarking(qubit_name, nr_cliffords, nr_seeds, net_clifford=0, restless=False, label='randomized_benchmarking', cal_points=True, double_curves=True): ''' Input pars: nr_cliffords: list nr_cliffords for which to generate RB seqs nr_seeds: int nr_seeds for which to generate RB seqs net_clifford: int index of net clifford the sequence should perform 0 corresponds to Identity and 3 corresponds to X180 restless: bool, does not initialize if restless is True label: some string that can be used as a label. cal_points: bool whether to replace the last two elements with calibration points, set to False if you want to measure a single element (for e.g. optimization) double_curves: Alternates between net clifford 0 and 3 returns: qasm_file generates a qasm file for single qubit Clifford based randomized benchmarking. ''' net_cliffords = [0, 3] # Exists purely for the double curves mode filename = join(base_qasm_path, label+'.qasm') qasm_file = mopen(filename, mode='w') qasm_file.writelines('qubit {} \n'.format(qubit_name)) i = 0 for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): if not restless: qasm_file.writelines('init_all \n') if cal_points and (j == (len(nr_cliffords)-4) or j == (len(nr_cliffords)-3)): qasm_file.writelines('RO {} \n'.format(qubit_name)) elif cal_points and (j == (len(nr_cliffords)-2) or j == (len(nr_cliffords)-1)): qasm_file.writelines('X180 {} \n'.format(qubit_name)) qasm_file.writelines('RO {} \n'.format(qubit_name)) else: if double_curves: net_clifford = net_cliffords[i % 2] i += 1 cl_seq = rb.randomized_benchmarking_sequence( n_cl, desired_net_cl=net_clifford) pulse_keys = rb.decompose_clifford_seq(cl_seq) for pulse in pulse_keys: if pulse != 'I': qasm_file.writelines('{} {}\n'.format( pulse, qubit_name)) qasm_file.writelines('RO {} \n'.format(qubit_name)) qasm_file.close() return qasm_file
def rb_block(self, sp1d_idx, sp2d_idx, **kw): """ Creates simultaneous blocks of RB pulses for each task in preprocessed_task_list. Args: sp1d_idx (int): current iteration index in the 1D sweep points array sp2d_idx (int): current iteration index in the 2D sweep points array Keyword args: interleaved_gate (see docstring of parent class) """ interleaved_gate = kw.get('interleaved_gate', None) pulse_op_codes_list = [] tl = [self.preprocessed_task_list[0]] if self.identical_pulses else \ self.preprocessed_task_list for i, task in enumerate(tl): param_name = 'seeds' if interleaved_gate is None else 'seeds_irb' seed_idx = sp1d_idx if self.sweep_type['seeds'] == 0 else sp2d_idx clf_idx = sp1d_idx if self.sweep_type[ 'cliffords'] == 0 else sp2d_idx seed = task['sweep_points'].get_sweep_params_property( 'values', self.sweep_type['seeds'], param_name)[seed_idx, clf_idx] clifford = task['sweep_points'].get_sweep_params_property( 'values', self.sweep_type['cliffords'], 'cliffords')[clf_idx] cl_seq = rb.randomized_benchmarking_sequence( clifford, seed=seed, interleaved_gate=interleaved_gate) pulse_list = rb.decompose_clifford_seq( cl_seq, gate_decomp=self.gate_decomposition) if self.purity: idx = sp1d_idx if self.sweep_type['seeds'] == 0 else sp2d_idx pulse_list += [self.tomo_pulses[idx % 3]] pulse_op_codes_list += [pulse_list] rb_block_list = [ self.block_from_ops(f"rb_{task['qb']}", [ f"{p} {task['qb']}" for p in pulse_op_codes_list[0 if self.identical_pulses else i] ]) for i, task in enumerate(self.preprocessed_task_list) ] return self.simultaneous_blocks(f'sim_rb_{sp1d_idx}{sp1d_idx}', rb_block_list, block_align='end', destroy=self.fast_mode)
def test_recovery_Y180_irb(self): cliffords = [0, 1, 50, 100] nr_seeds = 100 for cl in cliffords: for _ in range(nr_seeds): cl_seq = rb.randomized_benchmarking_sequence( cl, desired_net_cl=0, interleaved_gate='Y180') for decomp in ['HZ', 'XY']: pulse_keys = rb.decompose_clifford_seq(cl_seq, gate_decomp=decomp) gproduct = qtp.tensor(qtp.identity(2)) for pk in pulse_keys: gproduct = self.standard_pulses[pk] * gproduct x = gproduct.full() / gproduct.full()[0][0] self.assertTrue( np.all((np.allclose(np.real(x), np.eye(2)), np.allclose(np.imag(x), np.zeros(2)))))
def character_benchmarking( qubits: list, platf_cfg: str, nr_cliffords, nr_seeds: int, interleaving_cliffords=[None], program_name: str = "character_benchmarking", cal_points: bool = True, f_state_cal_pts: bool = True, flux_codeword="cz", recompile: bool = True, ): """ Create OpenQL program to perform two-qubit character benchmarking. Character benchmarking is described in: https://arxiv.org/abs/1808.00358 (theory) https://arxiv.org/abs/1811.04002 (implementation in Si/SiGe spins) Two-qubit character benchmarking: q0: P - C1 - C2 - C3 - ... - Cn- R - M q1: P - C1 - C2 - C3 - ... - Cn- R - M P -> Single qubit Pauli's. Single qubit Paulis are chosen so as to prepare in |00>, |01>, |10> and |11>. N.B. data should be averaged over all single qubit Paulis. Ci -> Single qubit Cliffords, different seqs for both qubits. R -> Recovery Clifford so that seq of C1 - Cn correspond to Idx. M -> Measurement in Z-basis. Outcomes should be averaged according to the "character function". Averaging scheme: seeds (average over different randomizations) nr of cliffords (peform for different nr of cliffords) paulis (perform for different Paulis) """ assert len(qubits) == 2 p = oqh.create_program(program_name, platf_cfg) this_file = inspect.getfile(inspect.currentframe()) # Ensure that programs are recompiled when changing the code as well recompile_dict = oqh.check_recompilation_needed_hash_based( program_fn=p.filename, platf_cfg=platf_cfg, clifford_rb_oql=this_file, recompile=recompile, ) if not recompile_dict["recompile"]: os.rename(recompile_dict["tmp_file"], recompile_dict["file"]) return p qubit_map = {"q0": qubits[0], "q1": qubits[1]} Cl = TwoQubitClifford paulis = { "00": ["II", "IZ", "ZI", "ZZ"], "01": ["IX", "IY", "ZX", "ZY"], "10": ["XI", "XZ", "YI", "YZ"], "11": ["XX", "XY", "YX", "YY"], } for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): for interleaving_cl in interleaving_cliffords: cl_seq = rb.randomized_benchmarking_sequence( n_cl, number_of_qubits=2, desired_net_cl=0, # desired to do identity max_clifford_idx=567, # The benchmarking group is the single qubit Clifford group # for two qubits this corresponds to all single qubit like # Cliffords. interleaving_cl=interleaving_cl, ) cl_seq_decomposed = [] # first element not included in decomposition because it will # be merged with the character paulis for cl in cl_seq[1:]: # hacking in exception for benchmarking only CZ # (not as a member of CNOT-like group) if cl == 104368: cl_seq_decomposed.append([("CZ", ["q0", "q1"])]) else: cl_seq_decomposed.append(Cl(cl).gate_decomposition) for pauli_type in paulis: # select a random pauli from the different types pauli = paulis[pauli_type][np.random.randint(4)] # merge the pauli with the first element of the cl seq. cl0 = Cl(common_cliffords[pauli]) # N.B. multiplication order is opposite of order in time # -> the first element in time (cl0) is on the right combined_cl0 = Cl(cl_seq[0]) * cl0 char_bench_seq_decomposed = [ combined_cl0.gate_decomposition ] + cl_seq_decomposed k = oqh.create_kernel( "CharBench_P{}_{}Cl_s{}_inter{}".format( pauli, int(n_cl), seed, interleaving_cl ), p, ) for qubit_idx in qubit_map.values(): k.prepz(qubit_idx) for gates in char_bench_seq_decomposed: for g, q in gates: if isinstance(q, str): k.gate(g, [qubit_map[q]]) elif isinstance(q, list): # proper codeword # k.gate(g, [qubit_map[q[0]], qubit_map[q[1]]]) # This is a hack because we cannot # properly trigger CZ gates. k.gate("wait", [], 0) k.gate(flux_codeword, [2, 0]) k.gate("wait", [], 0) for qubit_idx in qubit_map.values(): k.measure(qubit_idx) p.add_kernel(k) if cal_points: if f_state_cal_pts: combinations = ["00", "01", "10", "11", "02", "20", "22"] else: combinations = ["00", "01", "10", "11"] p = oqh.add_multi_q_cal_points(p, qubits=qubits, combinations=combinations) p = oqh.compile(p) # Just before returning we rename the hashes file as an indication of the # integrity of the RB code os.rename(recompile_dict["tmp_file"], recompile_dict["file"]) return p
raise ValueError("Could not find flux duration. Specify manually!") for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): for interleaving_cl in interleaving_cliffords: if ( not simultaneous_single_qubit_RB and not simultaneous_single_qubit_parking_RB ): # ############ 1 qubit, or 2 qubits using TwoQubitClifford # generate sequence for net_clifford in net_cliffords: cl_seq = rb.randomized_benchmarking_sequence( n_cl, number_of_qubits=number_of_qubits, desired_net_cl=net_clifford, max_clifford_idx=max_clifford_idx, interleaving_cl=interleaving_cl, ) net_cl_seq = rb.calculate_net_clifford(cl_seq, Cl) # decompose cl_seq_decomposed = [None] * len(cl_seq) for i,cl in enumerate(cl_seq): # benchmarking only CZ (not as a member of CNOT group) if cl == 104368: # 104368 = 100_000 + CZ cl_seq_decomposed[i] = [("CZ", ["q0", "q1"])] # benchmarking only idling identity, with duration of cz # see below where wait-time is added elif cl == 100_000: cl_seq_decomposed[i] = [("I", ["q0", "q1"])]
def character_benchmarking(qubits: list, platf_cfg: str, nr_cliffords, nr_seeds: int, interleaving_cliffords=[None], program_name: str = 'character_benchmarking', cal_points: bool = True, f_state_cal_pts: bool = True, flux_codeword='cz', recompile: bool = True): """ Create OpenQL program to perform two-qubit character benchmarking. Character benchmarking is described in: https://arxiv.org/abs/1808.00358 (theory) https://arxiv.org/abs/1811.04002 (implementation in Si/SiGe spins) Two-qubit character benchmarking: q0: P - C1 - C2 - C3 - ... - Cn- R - M q1: P - C1 - C2 - C3 - ... - Cn- R - M P -> Single qubit Pauli's. Single qubit Paulis are chosen so as to prepare in |00>, |01>, |10> and |11>. N.B. data should be averaged over all single qubit Paulis. Ci -> Single qubit Cliffords, different seqs for both qubits. R -> Recovery Clifford so that seq of C1 - Cn correspond to Idx. M -> Measurement in Z-basis. Outcomes should be averaged according to the "character function". Averaging scheme: seeds (average over different randomizations) nr of cliffords (peform for different nr of cliffords) paulis (perform for different Paulis) """ assert len(qubits) == 2 p = oqh.create_program(program_name, platf_cfg) # attribute get's added to program to help finding the output files p.filename = join(p.output_dir, p.name + '.qisa') if not oqh.check_recompilation_needed( program_fn=p.filename, platf_cfg=platf_cfg, recompile=recompile): return p qubit_map = {'q0': qubits[0], 'q1': qubits[1]} Cl = TwoQubitClifford paulis = { '00': ['II', 'IZ', 'ZI', 'ZZ'], '01': ['IX', 'IY', 'ZX', 'ZY'], '10': ['XI', 'XZ', 'YI', 'YZ'], '11': ['XX', 'XY', 'YX', 'YY'] } for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): for interleaving_cl in interleaving_cliffords: cl_seq = rb.randomized_benchmarking_sequence( n_cl, number_of_qubits=2, desired_net_cl=0, # desired to do identity max_clifford_idx=567, # The benchmarking group is the single qubit Clifford group # for two qubits this corresponds to all single qubit like # Cliffords. interleaving_cl=interleaving_cl) cl_seq_decomposed = [] # first element not included in decomposition because it will # be merged with the character paulis for cl in cl_seq[1:]: # hacking in exception for benchmarking only CZ # (not as a member of CNOT-like group) if cl == -4368: cl_seq_decomposed.append([('CZ', ['q0', 'q1'])]) else: cl_seq_decomposed.append(Cl(cl).gate_decomposition) for pauli_type in paulis: # select a random pauli from the different types pauli = paulis[pauli_type][np.random.randint(4)] # merge the pauli with the first element of the cl seq. cl0 = Cl(common_cliffords[pauli]) # N.B. multiplication order is opposite of order in time # -> the first element in time (cl0) is on the right combined_cl0 = Cl(cl_seq[0]) * cl0 char_bench_seq_decomposed = \ [combined_cl0.gate_decomposition] + cl_seq_decomposed k = oqh.create_kernel( 'CharBench_P{}_{}Cl_s{}_inter{}'.format( pauli, int(n_cl), seed, interleaving_cl), p) for qubit_idx in qubit_map.values(): k.prepz(qubit_idx) for gates in char_bench_seq_decomposed: for g, q in gates: if isinstance(q, str): k.gate(g, [qubit_map[q]]) elif isinstance(q, list): # proper codeword # k.gate(g, [qubit_map[q[0]], qubit_map[q[1]]]) # This is a hack because we cannot # properly trigger CZ gates. k.gate("wait", list(qubit_map.values()), 0) k.gate(flux_codeword, [2, 0]) k.gate("wait", list(qubit_map.values()), 0) for qubit_idx in qubit_map.values(): k.measure(qubit_idx) p.add_kernel(k) if cal_points: if f_state_cal_pts: combinations = ['00', '01', '10', '11', '02', '20', '22'] else: combinations = ['00', '01', '10', '11'] p = oqh.add_multi_q_cal_points(p, qubits=qubits, combinations=combinations) p = oqh.compile(p) return p
def randomized_benchmarking(qubits: list, platf_cfg: str, nr_cliffords, nr_seeds: int, net_cliffords: list = [0], max_clifford_idx: int = 11520, flux_codeword: str = 'cz', simultaneous_single_qubit_RB=False, initialize: bool = True, interleaving_cliffords=[None], program_name: str = 'randomized_benchmarking', cal_points: bool = True, f_state_cal_pts: bool = True, sim_cz_qubits: list = None, recompile: bool = True): ''' Input pars: qubits: list of ints specifying qubit indices. based on the length this function detects if it should generate a single or two qubit RB sequence. platf_cfg: filename of the platform config file nr_cliffords: list nr_cliffords for which to generate RB seqs nr_seeds: int nr_seeds for which to generate RB seqs net_cliffords: list of ints index of net clifford the sequence should perform. See examples below on how to use this. Important clifford indices 0 -> Idx 3 -> rx180 3*24+3 -> {rx180 q0 | rx180 q1} 4368 -> CZ max_clifford_idx: Set's the maximum clifford group index from which to sample random cliffords. Important clifford indices 24 -> Size of the single qubit Cl group 576 -> Size of the single qubit like class contained in the two qubit Cl group 11520 -> Size of the complete two qubit Cl group initialize: if True initializes qubits to 0, disable for restless tuning interleaving_cliffords: list of integers which specifies which cliffords to interleave the sequence with (for interleaved RB) program_name: some string that can be used as a label. cal_points: bool whether to replace the last two elements with calibration points, set to False if you want to measure a single element (for e.g. optimization) sim_cz_qubits: A list of qubit indices on which a simultaneous cz instruction must be applied. This is for characterizing CZ gates that are intended to be performed in parallel with other CZ gates. recompile: True -> compiles the program, 'as needed' -> compares program to timestamp of config and existence, if required recompile. False -> compares program to timestamp of config. if compilation is required raises a ValueError If the program is more recent than the config it returns an empty OpenQL program object with the intended filename that can be used to upload the previously compiled file. Returns: p: OpenQL Program object *************************************************************************** Examples: 1. Single qubit randomized benchmarking: p = cl_oql.randomized_benchmarking( qubits=[0], nr_cliffords=[2, 4, 8, 16, 32, 128, 512, 1024], nr_seeds=1, # for CCL memory reasons platf_cfg=qubit.cfg_openql_platform_fn(), program_name='RB_{}'.format(i)) 2. Two qubit simultaneous randomized benchmarking: p = cl_oql.randomized_benchmarking( qubits=[0, 1], # simultaneous RB on both qubits simultaneous_single_qubit_RB=True, nr_cliffords=[2, 4, 8, 16, 32, 128, 512, 1024], nr_seeds=1, # for CCL memory reasons platf_cfg=qubit.cfg_openql_platform_fn(), program_name='RB_{}'.format(i)) 3. Single qubit interleaved randomized benchmarking: p = cl_oql.randomized_benchmarking( qubits=[0], interleaving_cliffords=[None, 0, 16, 3], cal_points=False # relevant here because of data binning nr_cliffords=[2, 4, 8, 16, 32, 128, 512, 1024], nr_seeds=1, platf_cfg=qubit.cfg_openql_platform_fn(), program_name='Interleaved_RB_s{}_int{}_ncl{}_{}'.format(i)) ''' p = oqh.create_program(program_name, platf_cfg) # attribute get's added to program to help finding the output files p.filename = join(p.output_dir, p.name + '.qisa') # FIXME: platform dependency if not oqh.check_recompilation_needed( program_fn=p.filename, platf_cfg=platf_cfg, recompile=recompile): return p if len(qubits) == 1: qubit_map = {'q0': qubits[0]} number_of_qubits = 1 Cl = SingleQubitClifford elif len(qubits) == 2 and not simultaneous_single_qubit_RB: qubit_map = {'q0': qubits[0], 'q1': qubits[1]} number_of_qubits = 2 Cl = TwoQubitClifford elif len(qubits) == 2 and simultaneous_single_qubit_RB: qubit_map = {'q0': qubits[0], 'q1': qubits[1]} # arguments used to generate 2 single qubit sequences number_of_qubits = 2 Cl = SingleQubitClifford else: raise NotImplementedError() for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): for interleaving_cl in interleaving_cliffords: if not simultaneous_single_qubit_RB: cl_seq = rb.randomized_benchmarking_sequence( n_cl, number_of_qubits=number_of_qubits, desired_net_cl=None, # net_clifford, max_clifford_idx=max_clifford_idx, interleaving_cl=interleaving_cl) net_cl_seq = rb.calculate_net_clifford(cl_seq, Cl) cl_seq_decomposed = [] for cl in cl_seq: # FIXME: hacking in exception for benchmarking only CZ # (not as a member of CNOT group) if cl == -4368: cl_seq_decomposed.append([('CZ', ['q0', 'q1'])]) else: cl_seq_decomposed.append(Cl(cl).gate_decomposition) for net_clifford in net_cliffords: recovery_to_idx_clifford = net_cl_seq.get_inverse() recovery_clifford = Cl( net_clifford) * recovery_to_idx_clifford cl_seq_decomposed_with_net = cl_seq_decomposed + \ [recovery_clifford.gate_decomposition] k = oqh.create_kernel( 'RB_{}Cl_s{}_net{}_inter{}'.format( int(n_cl), seed, net_clifford, interleaving_cl), p) if initialize: for qubit_idx in qubit_map.values(): k.prepz(qubit_idx) for gates in cl_seq_decomposed_with_net: for g, q in gates: if isinstance(q, str): k.gate(g, [qubit_map[q]]) elif isinstance(q, list): if sim_cz_qubits is None: k.gate("wait", list(qubit_map.values()), 0) k.gate( flux_codeword, list(qubit_map.values()), ) # fix for QCC k.gate("wait", list(qubit_map.values()), 0) else: # A simultaneous CZ is applied to characterize cz gates that # have been calibrated to be used in parallel. k.gate( "wait", list(qubit_map.values()) + sim_cz_qubits, 0) k.gate( flux_codeword, list(qubit_map.values()), ) # fix for QCC k.gate(flux_codeword, sim_cz_qubits) # fix for QCC k.gate( "wait", list(qubit_map.values()) + sim_cz_qubits, 0) # FIXME: This hack is required to align multiplexed RO in openQL.. k.gate("wait", list(qubit_map.values()), 0) for qubit_idx in qubit_map.values(): k.measure(qubit_idx) k.gate("wait", list(qubit_map.values()), 0) p.add_kernel(k) elif simultaneous_single_qubit_RB: for net_clifford in net_cliffords: k = oqh.create_kernel( 'RB_{}Cl_s{}_net{}_inter{}'.format( int(n_cl), seed, net_clifford, interleaving_cl), p) if initialize: for qubit_idx in qubit_map.values(): k.prepz(qubit_idx) # FIXME: Gate seqs is a hack for failing openql scheduling gate_seqs = [[], []] for gsi, q_idx in enumerate(qubits): cl_seq = rb.randomized_benchmarking_sequence( n_cl, number_of_qubits=1, desired_net_cl=net_clifford, interleaving_cl=interleaving_cl) for cl in cl_seq: gates = Cl(cl).gate_decomposition # for g, q in gates: # k.gate(g, q_idx) # FIXME: THIS is a hack because of OpenQL # scheduling issues #157 gate_seqs[gsi] += gates # OpenQL #157 HACK l = max([len(gate_seqs[0]), len(gate_seqs[1])]) for gi in range(l): for gj, q_idx in enumerate(qubits): # gj = 0 # q_idx = 0 try: # for possible different lengths in gate_seqs g = gate_seqs[gj][gi] k.gate(g[0], [q_idx]) except IndexError as e: pass # end of #157 HACK # FIXME: This hack is required to align multiplexed RO in openQL.. k.gate("wait", list(qubit_map.values()), 0) for qubit_idx in qubit_map.values(): k.measure(qubit_idx) k.gate("wait", list(qubit_map.values()), 0) p.add_kernel(k) if cal_points: if number_of_qubits == 1: p = oqh.add_single_qubit_cal_points( p, qubit_idx=qubits[0], f_state_cal_pts=f_state_cal_pts) elif number_of_qubits == 2: if f_state_cal_pts: combinations = ['00', '01', '10', '11', '02', '20', '22'] else: combinations = ['00', '01', '10', '11'] p = oqh.add_multi_q_cal_points(p, qubits=qubits, combinations=combinations) p = oqh.compile(p) return p
def randomized_renchmarking_seqs(qb_name, operation_dict, cliffords, nr_seeds=None, net_clifford=0, gate_decomposition='HZ', interleaved_gate=None, upload=True, cl_sequence=None, sampling_seeds=None, cal_points=None, prep_params=dict()): """ Args qb_name (str): name of qubit operation_dict (dict): dict with all pulse dicts of qubit cliffords (array): array of ints specifying the number of random Cliffords to generate in each sequence nr_seeds (array): array of the form np.arange(nr_seeds_value) net_clifford (int): 0 or 1; whether the recovery Clifford returns qubits to ground statea (0) or puts them in the excited states (1) gate_decomposition (str): the decomposition of Clifford gates into primitives; can be "XY", "HZ", or "5Primitives" interleaved_gate (str): pycqed name for a gate upload (bool): whether to upload sequence to AWGs cl_sequence (list): the Clifford sequence to use for all seeds. Can also be lists of lists in which case the user must ensure that len(nr seeds) % len(cl_sequence) == 0. sampling_seeds (array of ints): ints that will be used as seeds for the random generation of Cliffords. Should have the same length as nr_seeds. cal_points (CalibrationPoints): instance of CalibrationPoints prep_params (dict): qubit preparation_params dict """ seq_name = '1Qb_RB_sequence' if sampling_seeds is None: if nr_seeds is None: raise ValueError('Please provide either "sampling_seeds" or ' '"nr_seeds."') sampling_seeds = [None] * len(nr_seeds) else: nr_seeds = np.arange(len(sampling_seeds)) if cl_sequence is not None: if isinstance(cl_sequence[0], list): # if cl_sequence is a list of lists such that # len(nr_seeds) != len(cl_sequence) but # len(nr_seeds) % len(cl_sequence) == 0, # then create as many copies of the lists in cl_sequence until # len(cl_sequence) == len(nr_seeds). assert len(nr_seeds) % len(cl_sequence) == 0 k = len(nr_seeds) // len(cl_sequence) cl_seq_temp = k * cl_sequence sequences = [] for nCl in cliffords: pulse_list_list_all = [] for s in nr_seeds: if cl_sequence is None: cl_seq = rb.randomized_benchmarking_sequence( nCl, desired_net_cl=net_clifford, interleaved_gate=interleaved_gate, seed=sampling_seeds[s]) elif isinstance(cl_sequence[0], list): cl_seq = cl_seq_temp[s] else: cl_seq = cl_sequence pulse_keys = rb.decompose_clifford_seq( cl_seq, gate_decomp=gate_decomposition) # to avoid having only virtual gates in segment: pulse_keys = ['I'] + pulse_keys pulse_list = [ operation_dict[x + ' ' + qb_name] for x in pulse_keys ] pulse_list += [operation_dict['RO ' + qb_name]] pulse_list_w_prep = add_preparation_pulses(pulse_list, operation_dict, [qb_name], **prep_params) pulse_list_list_all.append(pulse_list_w_prep) seq = pulse_list_list_seq(pulse_list_list_all, seq_name + f'_{nCl}', upload=False) if cal_points is not None: seq.extend( cal_points.create_segments(operation_dict, **prep_params)) sequences.append(seq) # reuse sequencer memory by repeating readout pattern [s.repeat_ro(f"RO {qb_name}", operation_dict) for s in sequences] if upload: ps.Pulsar.get_instance().program_awgs(sequences[0]) return sequences, np.arange(sequences[0].n_acq_elements()), \ np.arange(len(cliffords))
def Randomized_Benchmarking_seq(pulse_pars, RO_pars, nr_cliffords, nr_seeds, net_clifford=0, post_msmt_delay=3e-6, cal_points=True, resetless=False, double_curves=False, seq_name=None, verbose=False, upload=True): ''' Input pars: pulse_pars: dict containing pulse pars RO_pars: dict containing RO pars nr_cliffords: list nr_cliffords for which to generate RB seqs nr_seeds: int nr_seeds for which to generate RB seqs net_clifford: int index of net clifford the sequence should perform 0 corresponds to Identity and 3 corresponds to X180 post_msmt_delay: cal_points: bool whether to replace the last two elements with calibration points, set to False if you want to measure a single element (for e.g. optimization) resetless: bool if False will append extra Id element if seq is longer than 50us to ensure proper initialization double_curves: Alternates between net clifford 0 and 3 upload: Upload to the AWG returns: seq, elements_list Conventional use: nr_cliffords = [n1, n2, n3 ....] cal_points = True Optimization use (resetless or not): nr_cliffords = [n] is a list with a single entry cal_points = False net_clifford = 3 (optional) make sure it does a net pi-pulse post_msmt_delay is set (optional) resetless (optional) ''' if seq_name is None: seq_name = 'RandomizedBenchmarking_sequence' seq = sequence.Sequence(seq_name) el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) net_cliffords = [0, 3] # Exists purely for the double curves mode i = 0 for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): if double_curves: net_clifford = net_cliffords[i % 2] i += 1 # only used for ensuring unique elt names if cal_points and (j == (len(nr_cliffords) - 4) or j == (len(nr_cliffords) - 3)): el = multi_pulse_elt(i, station, [pulses['I'], RO_pars]) elif cal_points and (j == (len(nr_cliffords) - 2) or j == (len(nr_cliffords) - 1)): el = multi_pulse_elt(i, station, [pulses['X180'], RO_pars]) else: cl_seq = rb.randomized_benchmarking_sequence( n_cl, desired_net_cl=net_clifford) pulse_keys = rb.decompose_clifford_seq(cl_seq) pulse_list = [pulses[x] for x in pulse_keys] pulse_list += [RO_pars] # copy first element and set extra wait pulse_list[0] = deepcopy(pulse_list[0]) pulse_list[0]['pulse_delay'] += post_msmt_delay el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) # If the element is too long, add in an extra wait elt # to skip a trigger if resetless and n_cl * pulse_pars['pulse_delay'] * 1.875 > 50e-6: el = multi_pulse_elt(i, station, [pulses['I']]) el_list.append(el) seq.append_element(el, trigger_wait=True) if upload: station.pulsar.program_awgs(seq, *el_list, verbose=verbose) return seq, el_list else: return seq, el_list
def test_net_cliff(self): for i in range(len(Clifford_group)): rb_seq = rb.randomized_benchmarking_sequence(500, desired_net_cl=i) net_cliff = rb.calculate_net_clifford(rb_seq) self.assertEqual(net_cliff, i)
def Randomized_Benchmarking_seq(pulse_pars, RO_pars, nr_cliffords, nr_seeds, net_clifford=0, post_msmt_delay=3e-6, cal_points=True, resetless=False, double_curves=False, seq_name=None, verbose=False, upload=True): ''' Input pars: pulse_pars: dict containing pulse pars RO_pars: dict containing RO pars nr_cliffords: list nr_cliffords for which to generate RB seqs nr_seeds: int nr_seeds for which to generate RB seqs net_clifford: int index of net clifford the sequence should perform 0 corresponds to Identity and 3 corresponds to X180 post_msmt_delay: cal_points: bool whether to replace the last two elements with calibration points, set to False if you want to measure a single element (for e.g. optimization) resetless: bool if False will append extra Id element if seq is longer than 50us to ensure proper initialization double_curves: Alternates between net clifford 0 and 3 upload: Upload to the AWG returns: seq, elements_list Conventional use: nr_cliffords = [n1, n2, n3 ....] cal_points = True Optimization use (resetless or not): nr_cliffords = [n] is a list with a single entry cal_points = False net_clifford = 3 (optional) make sure it does a net pi-pulse post_msmt_delay is set (optional) resetless (optional) ''' if seq_name is None: seq_name = 'RandomizedBenchmarking_sequence' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) net_cliffords = [0, 3] # Exists purely for the double curves mode i = 0 for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): if double_curves: net_clifford = net_cliffords[i%2] i += 1 # only used for ensuring unique elt names if cal_points and (j == (len(nr_cliffords)-4) or j == (len(nr_cliffords)-3)): el = multi_pulse_elt(i, station, [pulses['I'], RO_pars]) elif cal_points and (j == (len(nr_cliffords)-2) or j == (len(nr_cliffords)-1)): el = multi_pulse_elt(i, station, [pulses['X180'], RO_pars]) else: cl_seq = rb.randomized_benchmarking_sequence( n_cl, desired_net_cl=net_clifford) pulse_keys = rb.decompose_clifford_seq(cl_seq) pulse_list = [pulses[x] for x in pulse_keys] pulse_list += [RO_pars] # copy first element and set extra wait pulse_list[0] = deepcopy(pulse_list[0]) pulse_list[0]['pulse_delay'] += post_msmt_delay el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) # If the element is too long, add in an extra wait elt # to skip a trigger if resetless and n_cl*pulse_pars['pulse_delay']*1.875 > 50e-6: el = multi_pulse_elt(i, station, [pulses['I']]) el_list.append(el) seq.append_element(el, trigger_wait=True) if upload: station.components['AWG'].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) return seq, el_list else: return seq, el_list
def test_net_cliff(self): for i in range(len(clifford_group_single_qubit)): rb_seq = rb.randomized_benchmarking_sequence(500, desired_net_cl=i) net_cliff = rb.calculate_net_clifford(rb_seq).idx self.assertEqual(net_cliff, i)
def randomized_benchmarking(qubits: list, platf_cfg: str, nr_cliffords, nr_seeds: int, net_cliffords: list = [0], max_clifford_idx: int = 11520, initialize: bool = True, interleaving_cliffords=[None], program_name: str = 'randomized_benchmarking', cal_points: bool = True, f_state_cal_pts: bool = True, recompile: bool = True): ''' Input pars: qubits: list of ints specifying qubit indices. based on the length this function detects if it should generate a single or two qubit RB sequence. platf_cfg: filename of the platform config file nr_cliffords: list nr_cliffords for which to generate RB seqs nr_seeds: int nr_seeds for which to generate RB seqs net_cliffords: list of ints index of net clifford the sequence should perform. See examples below on how to use this. 0 -> Idx 3 -> rx180 3*24+3 -> {rx180 q0 | rx180 q1} initialize: if True initializes qubits to 0, disable for restless tuning program_name: some string that can be used as a label. cal_points: bool whether to replace the last two elements with calibration points, set to False if you want to measure a single element (for e.g. optimization) recompile: True -> compiles the program, 'as needed' -> compares program to timestamp of config and existence, if required recompile. False -> compares program to timestamp of config. if compilation is required raises a ValueError If the program is more recent than the config it returns an empty OpenQL program object with the intended filename that can be used to upload the previously compiled file. Returns: p: OpenQL Program object *************************************************************************** Examples: 1. Single qubit randomized benchmarking: p = cl_oql.randomized_benchmarking( qubits=[0], nr_cliffords=[2, 4, 8, 16, 32, 128, 512, 1024], nr_seeds=1, # for CCL memory reasons platf_cfg=qubit.cfg_openql_platform_fn(), program_name='RB_{}'.format(i)) 2. Two qubit simultaneous randomized benchmarking: p = cl_oql.randomized_benchmarking( qubits=[0, 1], # simultaneous RB on both qubits max_clifford_idx = 576, # to ensure only SQ Cliffords are drawn nr_cliffords=[2, 4, 8, 16, 32, 128, 512, 1024], nr_seeds=1, # for CCL memory reasons platf_cfg=qubit.cfg_openql_platform_fn(), program_name='RB_{}'.format(i)) 3. Single qubit interleaved randomized benchmarking: p = cl_oql.randomized_benchmarking( qubits=[0], interleaving_cliffords=[None, 0, 16, 3], cal_points=False # relevant here because of data binning nr_cliffords=[2, 4, 8, 16, 32, 128, 512, 1024], nr_seeds=1, platf_cfg=qubit.cfg_openql_platform_fn(), program_name='Interleaved_RB_s{}_int{}_ncl{}_{}'.format(i)) ''' platf = Platform('OpenQL_Platform', platf_cfg) p = Program(pname=program_name, nqubits=platf.get_qubit_number(), p=platf) # attribute get's added to program to help finding the output files p.output_dir = ql.get_output_dir() p.filename = join(p.output_dir, p.name + '.qisa') if not oqh.check_recompilation_needed( program_fn=p.filename, platf_cfg=platf_cfg, recompile=recompile): return p if len(qubits) == 1: qubit_map = {'q0': qubits[0]} number_of_qubits = 1 Cl = SingleQubitClifford elif len(qubits) == 2: qubit_map = {'q0': qubits[0], 'q1': qubits[1]} number_of_qubits = 2 Cl = TwoQubitClifford else: raise NotImplementedError() for seed in range(nr_seeds): for j, n_cl in enumerate(nr_cliffords): for interleaving_cl in interleaving_cliffords: for net_clifford in net_cliffords: k = Kernel('RB_{}Cl_s{}_net{}_inter{}'.format( n_cl, seed, net_clifford, interleaving_cl), p=platf) if initialize: for qubit_idx in qubit_map.values(): k.prepz(qubit_idx) cl_seq = rb.randomized_benchmarking_sequence( n_cl, number_of_qubits=number_of_qubits, desired_net_cl=net_clifford, max_clifford_idx=max_clifford_idx, interleaving_cl=interleaving_cl) for cl in cl_seq: gates = Cl(cl).gate_decomposition for g, q in gates: if isinstance(q, str): k.gate(g, qubit_map[q]) elif isinstance(q, list): # proper codeword k.gate(g, [qubit_map[q[0]], qubit_map[q[1]]]) # This hack is required to align multiplexed RO in openQL.. k.gate("wait", list(qubit_map.values()), 0) for qubit_idx in qubit_map.values(): k.measure(qubit_idx) k.gate("wait", list(qubit_map.values()), 0) p.add_kernel(k) if cal_points: if number_of_qubits == 1: p = add_single_qubit_cal_points( p, platf=platf, qubit_idx=qubits[0], f_state_cal_pts=f_state_cal_pts) elif number_of_qubits == 2: if f_state_cal_pts: combinations = ['00', '01', '10', '11', '02', '20', '22'] else: combinations = ['00', '01', '10', '11'] p = add_multi_q_cal_points(p, platf=platf, qubits=qubits, combinations=combinations) with suppress_stdout(): p.compile(verbose=False) return p