def correction_ghz4(measurements, N, operation_pos): # print("Measurements: ", measurements) # There are two protocols in this case: # 1 or 2 ancilla bell pairs N_ancillas = len(measurements) # If 1 bell pair is used: Then even measument sum requires no correction. # Odd measurement requires X correction if N_ancillas == 2: if sum(measurements) % 2 == 1: return [ qt.rx(np.pi, N, operation_pos[0]), qt.rx(np.pi, N, operation_pos[1]) ] else: return [] # If two pairs are used then odd measurement means the state collapsed into # something mixed, as a result of entanglement disitillation. # Even result may o no require correction, do calculation by hand elif N_ancillas == 4: if sum(measurements) % 2 == 1: return None # Results that require no correction. no_correction_list = [0, 3, 12, 15] # Transform measurement result into int by binary transform m_bin = int(''.join(map(str, measurements)), 2) if m_bin in no_correction_list: return [] else: return [ qt.rx(np.pi, N, operation_pos[0]), qt.rx(np.pi, N, operation_pos[1]) ]
def correction_ghz3(measurements, N, operation_pos): """ Correction opertions for the GHZ state of size 3. On the case when 3 bell pairs are collapsed into the GHZ. """ N_ancillas = len(measurements) if N_ancillas == 1: # Only one qubit in the Bell states are used is measured # Result 0 requires no correction, result 1 requires to apply a Pauli X if measurements == [0]: return [] elif measurements == [1]: return [qt.rx(np.pi, N, operation_pos)] elif N_ancillas == 3: if sum(measurements) % 2 == 1: return None no_correction_list = [0, 3] m_bin = int(''.join(map(str, measurements)), 2) if m_bin in no_correction_list: return [] else: return [qt.rx(np.pi, N, operation_pos)]
def get2(x): """ parametrized (6 parameters) circuitry which can create a c. GHZ state i.e. |000> - |111>""" g1 = qt.tensor(qt.rx(x[0]), qt.rx(x[1]), qt.rx(x[2])) g2 = qt.cnot(3, 1, 2) g3 = qt.cnot(3, 0, 2) g4 = qt.tensor(qt.rx(x[3]), qt.rx(x[4]), qt.ry(x[5])) return g4 * g3 * g2 * g1 * qt.tensor(zero, zero, zero)
def circuitZBraidingCorrectionSimulation(psi0, c_ops=[]): N = 8 schedule = [] for i in range(2): # Z braiding, stage 1 schedule += [rx(np.pi / 2., N=N, target=i) for i in [4, 5]] # Z braiding, stage 2 schedule += [rz(-np.pi / 2., N=N, target=i) for i in [4, 5]] # Z braiding, stage 3 schedule += [controlled_gate(sigmaz(), N=N, control=4, target=5)] # Z braiding, stage 4 schedule += [rx(-np.pi / 2., N=N, target=i) for i in [4, 5]] # perform time evolution and return the final state return scheduledUnitaryEvolution(psi0, schedule)
def as_qobj_operator(self, instance: "GateInstance") -> qutip.Qobj: p = self.decompose_params(instance.params) op = qutip.rx(0, self.num_qubits, 0) i = 0 for gate_type, targets in self.gate_placements: fake_instance = GateInstance(gate_type, targets, p[i:i + gate_type.num_params]) op = self._expand_gate(gate_type.as_qobj_operator(fake_instance), gate_type.num_qubits, self.num_qubits, targets) * op i += gate_type.num_params return op
def CRt_echo(tend, psi0): # Echoed CR in qubit 1 frame if tend == 0: return qt.expect(e_op_list, psi0) tlist = np.arange(0, tend, dt) output1 = qt.mesolve(Htp, psi0, tlist[0:int(len(tlist) / 2)], [], [], {}) psiEcho = qt.tensor(qt.rx(np.pi), qt.identity(2)) * output1.states[-1] output2 = qt.mesolve(Htm, psiEcho, tlist[int(len(tlist) / 2):], [], e_op_list, {}) return np.array(output2.expect)[:, -1]
def env_error_single(rho, a0, a1, t, N=1, pos=0): """Apply environmental error on a single qubit from the state rho.""" a = (a0 + a1)*t X = qt.rx(np.pi, N, pos) Y = qt.ry(np.pi, N, pos) Z = qt.rz(np.pi, N, pos) # ss = sigma_z * rho * sigma_z.dag() lamb = np.exp(-a * t) c1 = (3*lamb + 1)/4 c2 = (1 - lamb)/4 # print("T: ", t, "lamb: ", lamb) rho = (c1 * rho + c2 * (Z * rho * Z.dag() + X * rho * X.dag() + Y * rho * Y.dag())) return rho
def measure_single_Zbasis_random(rho, p, N=1, pos=0): """ Probabilisticly measure and collapse the state on the given position. Parameters ----------- rho : (densmat) the state to apply the noisy gate on p : (scalar) measurement error rate N : (int) total system size pos : (int) position of the qubit to be measured """ X = qt.rx(np.pi, N, pos) rho = (1 - p)*rho + p*(X * rho * X.dag()) measurement, collapsed_rho = ops.random_measure_single_Zbasis(rho, N, pos, True) return measurement, collapsed_rho
def measure_single_Zbasis_forced(rho, p, project, N=1, pos=0): """ Collapse the state on the given position and to the given projector. Parameters ----------- rho : (densmat) the state to apply the noisy gate on p : (scalar) measurement error rate project : (scalar) 0 or 1, projector involved in the measurement collapse N : (int) total system size pos : (int) position of the qubit to be measured """ X = qt.rx(np.pi, N, pos) rho = (1 - p)*rho + p*(X * rho * X.dag()) p, collapsed_rho = ops.forced_measure_single_Zbasis(rho, N, pos, project, True) return collapsed_rho
def teleport(state, mres): X_ = qt.rx(-np.pi, N=3, target=2) Z_ = qt.rz(-np.pi, N=3, target=2) state_array = state.full() if mres == 1: state = -1j * X_ * state amp = [state_array[3], state_array[2]] return qt.Qobj(amp).unit() if mres == 2: state = -1j * Z_ * state amp = [state_array[4], -state_array[5]] return qt.Qobj(amp).unit() if mres == 3: state = -1 * Z_ * X_ * state amp = [state_array[7], -state_array[6]] return qt.Qobj(amp).unit() amp = [state_array[0], state_array[1]] return qt.Qobj(amp).unit()
def _generate_bell_pair_BK(self): # Generate a Bell pair using the Barret-Kok protocol. # For this case set the initial state to be |+> # Probaility of success s = .5 r = (1 - self.eta) * s / (1 - self.eta * s) p_success = (1 - r) * self.eta**2 # This circuit number of steps attempts = self._success_number_of_attempts(p_success) + 1 time = self.time_lookup["bell_pair"] * attempts # Update check self.check["bell_pair"] += 1 # Generate Bell pair with F=1 bell = qt.bell_state('10') * qt.bell_state('10').dag() # Apply noisy 1q X to transform state bell = errs.single_qubit_gate(bell, qt.rx(np.pi, 2, 0), self.ps, 2, 0) return time, bell
def plot_trajectories(self, times, trajs, plot_title=''): ''' Plot output of a simulation result on the Bloch sphere ''' f = plt.figure(figsize=(5, 5), facecolor='white') f.suptitle(plot_title, x=0.2) # plt.title(plot_title) xp2 = qu.rx(np.pi * 0.5) yp2 = qu.ry(np.pi * 0.5) zp2 = qu.rz(np.pi * 0.5) xpi = qu.sigmax() ypi = qu.sigmay() zpi = qu.sigmaz() up = qu.basis(2, 0) dn = qu.basis(2, 1) # ax = f.add_subplot(1, 1, 1, axisbg='red') # p1 = f.add_subplot(2,2,1) # plt.plot(times,trajs[0]) # legend(['OneX','OneY','OneZ'],loc='best') # p2 = f.add_subplot(2,2,3) # pure = norm(trajs[0],axis=1) # plt.plot(times,pure) # legend(['Purity'],loc='best') # ylim(-0.1,1.1) # p3 = f.add_subplot(1,2,2, projection='3d') b = qu.Bloch(fig=f) #,axes=p3) b.zlabel = [r"$\left|1\right\rangle $", r"$\left|0\right\rangle$"] b.xlabel = [r"$ X $", r""] b.ylabel = [r"$ Y $", r""] b.vector_color = sb.color_palette() b.add_states([yp2 * up, xp2 * xpi * up, up]) b.point_color = sb.color_palette('dark')[3:4] b.add_points(trajs, 'l') # b.add_points(trajs[0][0].transpose(),'s') b.font_size = 30 b.sphere_color = '000000' b.render(f) b.show()
def teleport(state, result): X_ = qt.rx(-np.pi, N=3, target=2) Z_ = qt.rz(-np.pi, N=3, target=2) state_array = state.full() if result == 1: state = -1j * Z_ * state amp = [-state_array[2], state_array[3]] return qt.Qobj(amp).unit() if result == 2: state = -1j * X_ * state amp = [state_array[5], state_array[4]] return qt.Qobj(amp).unit() if result == 0: state = -1 * Z_ * X_ * state amp = [state_array[1], -state_array[0]] return qt.Qobj(amp).unit() amp = [-state_array[6], -state_array[7]] return qt.Qobj(amp).unit()
def start_epl(self, rho=None): """ Circuit that generates a Bell pair using the EPL protocol. NOTE: rho is not taken from arguments, only exists due to how 'circuit.py' is constructed. """ self._reset_check() # Generate Bell pairs # First pair with swap time1, bell1 = self._generate_bell_single_click() bell1 = self._swap_pair(bell1, [0, 1]) # Second pair time2, bell2 = self._generate_bell_single_click() self.check["time"] += time1 + time2 self.check["time0"] += time1 + time2 # Apply cutoff here # Dephase pair 1 rho = errs.env_error_all(bell1, self.a0, self.a1, time2) # Join state rho = qt.tensor(rho, bell2) # NOTE: Decide which state collapses. # Apply two qubit gates controls = [0, 1] targets = [2, 3] rho = self._apply_two_qubit_gates(rho, controls, targets, "X") # Measure ancillas in Z basis projections = [1] * 2 p_success, rho = self._collapse_ancillas_EPL(rho, targets) # Apply X to rotate state rho = self._apply_single_qubit_gates(rho, [qt.rx(np.pi, 2, 0)], [0]) return p_success, self.check, rho
def RX(self, target, theta): self.state = rx(theta, self.qubits, self.qubits - 1 - target) * self.state
def rx(self, theta : float) -> None: self.parent._apply(qt.rx(theta), self.qubit_id)
def get_sigmas(N=1, pos=0): """Return set of single qubit X Y Z gates.""" sigmas = [qt.qeye([2]*N), qt.rx(np.pi, N, pos), qt.ry(np.pi, N, pos), qt.rz(np.pi, N, pos)] return sigmas
def as_qobj_operator(self, instance: "GateInstance") -> qutip.Qobj: return qutip.rx(instance.params[0])
def create_data(time_per_count, num_samples, num_counts, gate_list, time_unit, noise_type=None, walking_amp=None, telegraph_amp=None, \ res=None, freq_list=None, amp_list=None, phase_list=None, start_f=None, stop_f=None, fluctuators=None, plot_noise=False, \ add_noise=False, noise_object=None, dc_angle_offset=0, constant_linear_drift=0): #time_per_shot: time in seconds for a single (prep-gate-measure+delay) #num_samples: how many timestamps and strings of counts you want to have #num_counts: how many data points to create (how many ones and zeros) per sample (i.e. per timestamp) --> affects both time of a sample and precision #num_shots: how many times (shots) you apply (prep-gate_list-meas) to get one count (a single 0 or 1) --> determines the time of one count, but won't affect precision #gate_list: gates you want to do for your operation, entered as a list of strings #xerr,yerr,zerr: 2D tuples with overrotation amplitude in radians and frequency in Hz #constant linear drift: enter in rads/second rho0 = _qt.operator_to_vector(_qt.ket2dm(_qt.basis(2, 0))) rho1 = _qt.operator_to_vector(_qt.ket2dm(_qt.basis(2, 1))) zero_counts = [] one_counts = [] timestep = num_counts * time_per_count #the time to get a full bitstring of zeros and ones for one sample, i.e. one timestamp timestamps = np.arange( timestep, num_samples * timestep, timestep) #array of 1*timestep, 2*timestep,....(num_samples)*timestep probs = [] total_time = (time_per_count * num_counts * num_samples) / time_unit sig = 0 if noise_type == "Sine": #this function returns the noise object so you can enter it back in as a parameter # in the event that you call the function repeatedly for an identical set of parameters if noise_object != None: sig = noise_object #print("REUSING NOISE OBJECT") while total_time > sig.times[-1] + timestep: sig.next_interval() #print("Doing a NEXT INTERVAL") else: #print("INITIALIZING NEW NOISE") sig = _ns.NoiseSignalSine(time_unit=time_unit) sig.configure_noise(resolution_factor=res, freq_list=freq_list, amp_list=amp_list, phase_list=phase_list, total_time=total_time) sig.init() if add_noise != None: sig.add_random_noise( add_noise ) #add normal noise with specified std deviation if requested elif noise_type == "Random Walk": sig = _ns.NoiseSignalRandomWalk(initial_seed=1234, time_unit=time_unit) sig.configure_noise(walking_amp, res, total_time) sig.init() elif noise_type == "Telegraph": sig = _ns.NoiseSignalTelegraph(initial_seed=1234, time_unit=time_unit) sig.configure_noise(exponent=1, amplitude=telegraph_amp, total_fluctuators=fluctuators, start_freq=start_f, stop_freq=stop_f, total_time=total_time) sig.init() sig.interpolation_settings(do_interpolation=True, resolution_factor=res) if plot_noise == True: sig.plot_noise_signal() angle_list = [] expected_angle_list = [] compressed_gate_list = compress_gate_list(gate_list) for time in timestamps: noise_at_time = 0 if noise_type != None: #print(time/time_unit) noise_at_time = sig[time / time_unit] rho = rho0 total_angle = 0 total_ideal_angle = 0 for gate in compressed_gate_list: gate_name = gate[0] gate_repetitions = gate[1] ''' Next step: calculate change in rotation error within each shot. Currently takes the time at the start of the experiment shot and applies that to all gates in one shot. Depending on the timescale of the error and time per shot, this simplification may need to be addressed so that each gate, say each Gx in (Gx)^11, has an error associated with its specific time, not the same error for all 11 Gx gates. ''' if gate_name == 'Gx': angle = ( np.pi / 2 + noise_at_time ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time ideal_angle = ( np.pi / 2 ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time rho = (_qt.to_super(_qt.rx(angle))) * rho #this section just keeps the angle between 0 and pi angle = angle % (2 * np.pi) ideal_angle = ideal_angle % (2 * np.pi) if angle > np.pi: angle = 2 * np.pi - angle if angle < 0: angle = 0 + abs(angle) if ideal_angle > np.pi: ideal_angle = 2 * np.pi - ideal_angle if ideal_angle < 0: ideal_angle = 0 + abs(ideal_angle) elif gate_name == 'Gy': angle = ( np.pi / 2 + noise_at_time ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time ideal_angle = ( np.pi / 2 ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time rho = (_qt.to_super(_qt.ry(angle))) * rho #this section just keeps the angle between 0 and pi angle = angle % (2 * np.pi) ideal_angle = ideal_angle % (2 * np.pi) if angle > np.pi: angle = 2 * np.pi - angle if angle < 0: angle = 0 + abs(angle) if ideal_angle > np.pi: ideal_angle = 2 * np.pi - ideal_angle if ideal_angle < 0: ideal_angle = 0 + abs(ideal_angle) elif gate_name == 'Gz': angle = ( np.pi / 2 + noise_at_time ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time ideal_angle = ( np.pi / 2 ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time rho = (_qt.to_super(_qt.rz(angle))) * rho #this section just keeps the angle between 0 and pi angle = angle % (2 * np.pi) ideal_angle = ideal_angle % (2 * np.pi) if angle > np.pi: angle = 2 * np.pi - angle if angle < 0: angle = 0 + abs(angle) if ideal_angle > np.pi: ideal_angle = 2 * np.pi - ideal_angle if ideal_angle < 0: ideal_angle = 0 + abs(ideal_angle) elif gate_name == "Gi": #apply only the oscillating drift angle, don't add it to pi/2 angle = ( noise_at_time ) * gate_repetitions + dc_angle_offset + constant_linear_drift * time ideal_angle = 0 + dc_angle_offset + constant_linear_drift * time print("applying Gi with angle ", angle) rho = (_qt.to_super(_qt.rz(angle))) * rho angle = angle % (2 * np.pi) ideal_angle = 0 if angle > np.pi: angle = 2 * np.pi - angle if angle < 0: angle = 0 + abs(angle) if ideal_angle > np.pi: ideal_angle = 2 * np.pi - ideal_angle if ideal_angle < 0: ideal_angle = 0 + abs(ideal_angle) total_angle += angle total_ideal_angle += ideal_angle #append the total rotation angle after timestamp 'time' angle_list.append(total_angle) expected_angle_list.append(total_ideal_angle) #calculate probabilities of being in 1 after the experiment has been applied p1 = (rho.dag() * rho1).norm() #fix the p1 if it exceeds 1 due to rounding error if p1 > 1: #print("p1 exceeds 1 for time {}".format(time)) #print("prob is {}".format(p1)) #print("Resetting to {}".format(2-p1)) p1 = 2 - p1 probs.append(p1) one_count = np.random.binomial( num_counts, p1 ) #simulates a summation of the number of 1-counts you get in one bitstring sample zero_count = num_counts - one_count #simulates summation of the number of 0-counts in one bitstring sample one_counts.append(one_count) zero_counts.append(zero_count) if plot_noise == True: plt.plot(timestamps, np.asarray(expected_angle_list), label="Ideal Angle", ls='dashed', color='orange') plt.plot(timestamps, np.asarray(angle_list), label="Drifting Angle") plt.legend() plt.xlabel("Time, seconds") plt.yticks(np.linspace(0, np.pi, 5), ['0', '$\pi/4$', '$\pi/2$', '$3\pi/4$', '$\pi$']) plt.ylabel("Angle, radians\n(Displayed between 0 and $\pi$)") plt.title("Time-Dependent Rotation Angle after each {}".format( gate_list_to_string(gate_list))) plt.grid() plt.show() plt.figure(figsize=(15, 3)) plt.plot(timestamps, probs) plt.ylim(0, 1) plt.xlim(timestamps[0], timestamps[-1]) plt.xlabel("Time, seconds") plt.ylabel("Probability of Measuring State {1}") plt.title("Simulated {} with {} Noise".format( gate_list_to_string(gate_list), noise_type)) plt.grid() plt.show() return (np.asarray(one_counts), np.asarray(zero_counts), np.asarray(timestamps), probs, np.asarray(expected_angle_list), np.asarray(angle_list), sig)
def ramsey_experiment(left_gate_list, right_gate_list, L, field_f, transition_f, nCounts, time_per_gate, gate_switching_time, \ experiment_sample_time, time_units=1e-6, noise_type=None, freq_list=0,amp_list=0, phase_list=0,\ start_f=0, stop_f=0, fluctuators=0, plot_noise = False): #left and right gate_lists: lists of the gates sandwiching the Gi gates #L: the number of Gi gates. If you want to vary this, make it a list #field_f: frequency of external field in Hz. To vary this, make it a list. Either L or field_f must vary. #transition_f: frequency of the qubit transition in Hz. #time_per_gate: total time to complete one Gx, Gy, Gi, or Gz #switching_time: additional time before you start any new gate or change gates #experiment_sample_time: time at which you trigger a single expeimrent (single count), usually 60 Hz triggered #nCounts: number of times to repeat one experiment (a single set of parameters) #time_units: baseline units (in seconds) for any additional drift noise signal you may want to add. Defaults to ms. #check that the input has something to be varied if type(L) == type(field_f): print("Error: Either L or field_f must vary over a range!") return None #this list will contain the varied parameter, either detuning in Hz or delay time in s varied_param = [] if type(L) == list: total_experiments = len(L) experiment_list = [] for l in L: experiment_list.append(left_gate_list + ['Gi'] * l + right_gate_list) field_f_list = [field_f] * total_experiments varied_param = [(time_per_gate * l + gate_switching_time) for l in L] else: total_experiments = len(field_f) experiment_list = [left_gate_list + ['Gi'] * L + right_gate_list ] * total_experiments field_f_list = field_f varied_param = delta_list #create a noise object: if noise_type != None and noise_type == "Sine": total_time = total_experiments * nCounts * experiment_sample_time + 1 #assumes that every count is taken every 0.016 seconds; no experiment takes longer sig = _ns.NoiseSignalSine(time_unit=time_units) sig.configure_noise(resolution_factor=1, freq_list=freq_list, amp_list=amp_list, phase_list=phase_list, total_time=total_time / time_units) sig.init() if plot_noise == True: sig.plot_noise_signal() probs = [ ] #a list of total_expeirment* elements. Has the probability for each experiment set (assumes constant p for all nCounts) time_per_experiment_set = [ ] #has the time at the start of each experiment set ones_counts = [] #number of 1s counted for each experiment set angles = [] #total theta rotation for each experiment set ideal_angles = [] #has the ideal theta rotation for each experiment set transition_f_list = [ ] #list of the transition frequency at the start of each experiment set detuning_list = [ ] #list of the detuning at the start of each experiment set absolute_time = 0 #seconds rho0 = _qt.operator_to_vector(_qt.ket2dm(_qt.basis(2, 0))) rho1 = _qt.operator_to_vector(_qt.ket2dm(_qt.basis(2, 1))) for experiment_index in range(total_experiments): experiment = experiment_list[experiment_index] compressed_experiment = compress_gate_list(experiment) #the following line assumes that each count for each experiment set is triggered at 0.0167 seconds (no single gate sequence can be longer than 1/60) absolute_time += experiment_sample_time * nCounts #print("Starting experiment set {} at {} s".format(experiment_index, absolute_time)) rho = rho0 total_angle = 0 total_ideal_angle = 0 modified_transition_f = transition_f detuning = field_f_list[experiment_index] - modified_transition_f for gate_name, repetitions in compressed_experiment: if noise_type != None: if absolute_time >= total_time: print("Abs time: {}, total_time: {}".format( absolute_time, total_time)) detuning_noise = sig[absolute_time / time_units] else: detuning_noise = 0 if gate_name == 'Gx': angle = (np.pi / 2) * repetitions ideal_angle = (np.pi / 2) * repetitions rho = (_qt.to_super(_qt.rx(angle))) * rho #this section just keeps the angle between 0 and pi angle = angle % (2 * np.pi) ideal_angle = ideal_angle % (2 * np.pi) if angle > np.pi: angle = 2 * np.pi - angle if angle < 0: angle = 0 + abs(angle) if ideal_angle > np.pi: ideal_angle = 2 * np.pi - ideal_angle if ideal_angle < 0: ideal_angle = 0 + abs(ideal_angle) elif gate_name == 'Gy': angle = (np.pi / 2) * repetitions ideal_angle = (np.pi / 2) * repetitions rho = (_qt.to_super(_qt.ry(angle))) * rho #this section just keeps the angle between 0 and pi angle = angle % (2 * np.pi) ideal_angle = ideal_angle % (2 * np.pi) if angle > np.pi: angle = 2 * np.pi - angle if angle < 0: angle = 0 + abs(angle) if ideal_angle > np.pi: ideal_angle = 2 * np.pi - ideal_angle if ideal_angle < 0: ideal_angle = 0 + abs(ideal_angle) elif gate_name == "Gi": #print("starting {} with z-rotation 2pi*{:.2f}".format(gate_list_to_string(experiment), detuning*(time_per_gate*repetitions + gate_switching_time))) #make the transition frequency oscillate between a fraction of its nominal value modified_transition_f = transition_f * (1 + detuning_noise) detuning = field_f_list[ experiment_index] - modified_transition_f angle = 2 * np.pi * detuning * (time_per_gate * repetitions + gate_switching_time) rho = (_qt.to_super(_qt.rz(angle))) * rho total_angle += angle total_ideal_angle += ideal_angle #calculate probabilities of being in 1 after the all the gates in the experiment have been applied p1 = (rho.dag() * rho1).norm() #fix the p1 if it exceeds 1 due to rounding error if p1 > 1: p1 = 2 - p1 #get nCounts of data (bits) for the experiment one_counts = np.random.binomial(nCounts, p1) angles.append(total_angle) ideal_angles.append(total_ideal_angle) probs.append(p1) ones_counts.append(one_counts) time_per_experiment_set.append(absolute_time) transition_f_list.append(modified_transition_f) detuning_list.append(detuning) return np.asarray(ones_counts), np.asarray( time_per_experiment_set), np.asarray(probs), np.asarray(varied_param)
def rx(self, theta: float) -> None: self.state = qt.rx(theta) * self.state
def CO_rx(Chromosome, phase=np.pi / 8): return np.dot(Chromosome, np.array(qc.rx(phase).full()))
def Rx(angle): return qt.rx(angle)