def circuitXXBraidingCorrectionSimulation(psi0, c_ops=[]): N = 8 schedule = [] for i in range(2): # XX braiding, stage 1 schedule += [ry(np.pi / 2., N=N, target=i) for i in [5, 6]] # XX braiding, stage 2 schedule += [rz(-np.pi / 2., N=N, target=i) for i in [5, 6]] # XX braiding, stage 3 schedule += [controlled_gate(sigmaz(), N=N, control=5, target=6)] # XX braiding, stage 4 schedule += [ry(-np.pi / 2., N=N, target=i) for i in [5, 6]] # perform time evolution and return the final state return scheduledUnitaryEvolution(psi0, schedule)
def random_unitary_gate(delta,alpha,theta,beta,value): gate = qt.Qobj(qt.phasegate(delta)*qt.rz(alpha)*qt.ry(theta)*qt.rz(beta)) if value == True: gate = gate *qt.Qobj([[0,1],[1,0]]) else: gate = gate return gate
def rando(orig): (n, n) = orig.shape theta = uniform(0.0, math.pi * 2.0) #pick a rotation any rotation phaser = randint(0, 3) if phaser == 0: gate = qt.phasegate(theta) elif phaser == 1: gate = qt.rz(theta) elif phaser == 2: gate = qt.ry(theta) else: gate = qt.globalphase(theta) (m, m) = gate.shape cc = 0 while n != m and cc < 10: pick = randint(0, 1) if not pick: gate = qt.tensor(gate, id2) gate = tensor_fix(gate) else: gate = tensor_fix(qt.tensor(id2, gate)) (m, m) = gate.shape cc += 1 gate = gate * orig return gate
def alter_hadamard(hada,seed): (n,n)=hada.shape theta = uniform(0.0,math.pi*2.0) #pick a rotation any rotation phaser=randint(0,3) if phaser ==0: gate=qt.phasegate(theta) elif phaser == 1: gate=qt.rz(theta) elif phaser==2: gate = qt.ry(theta) else: gate=qt.globalphase(theta) #alter gate if seed == 0: u1=gate else: u1=id2 i=1 while u1.shape != (n,n): if i ==seed: #set a alteration on specified qubit u1=qt.tensor(u1,gate) u1=tensor_fix(u1) else: u1=qt.tensor(u1,id2) u1=tensor_fix(u1) i+=1 final_gate=u1*hada return final_gate
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 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 circuitTeleportationSimulation(psi, c_ops=[]): N = 8 psi0 = tensor([basis(2, 0), psi] + [basis(2, 0) for i in range(N - 2)]) schedule = [] # encoding, Hadamards stage 1, 2 schedule += [snot(N=N, target=i) for i in range(N)] # encoding, CZs, stage 3 schedule += [ controlled_gate(sigmaz(), N=N, control=0, target=1), controlled_gate(sigmaz(), N=N, control=2, target=3), controlled_gate(sigmaz(), N=N, control=4, target=5) ] # encoding, Hadamards, stage 4, 5 schedule += [snot(N=N, target=i) for i in [1, 3, 5]] # teleportation, stage 6 schedule += [ry(np.pi / 2., N=N, target=i) for i in [1, 2, 3, 4]] # teleportation, stage 7 schedule += [rz(-np.pi / 2., N=N, target=i) for i in [1, 2, 3, 4]] # teleportation, stage 8 schedule += [ controlled_gate(sigmaz(), N=N, control=1, target=2), controlled_gate(sigmaz(), N=N, control=3, target=4) ] # teleportation, stage 9 schedule += [ry(-np.pi / 2., N=N, target=i) for i in [1, 2, 3, 4]] # decoding, stage 10, 11 schedule += [snot(N=N, target=i) for i in [1, 3]] # decoding, stage 12 schedule += [ controlled_gate(sigmaz(), N=N, control=0, target=1), controlled_gate(sigmaz(), N=N, control=2, target=3) ] # decoding, stage 13, 14 schedule += [snot(N=N, target=i) for i in [0, 1, 2, 3]] # perform time evolution and return the final state return scheduledUnitaryEvolution(psi0, schedule)
def random_altered_unitary_gate(delta,alpha,theta,beta,value): if delta == 0.0 and alpha == 0.0 and theta == math.pi and value == True: angles = ['delta','alpha','beta'] else: angles = ['delta','alpha','theta','beta'] altered_variable = choice(angles) if altered_variable == 'delta': delta = uniform(0.0,2.0*math.pi) if altered_variable == 'alpha': alpha = uniform(0.0,2.0*math.pi) if altered_variable == 'theta': theta = uniform(0.0,2.0*math.pi) if altered_variable == 'beta': beta = uniform(0.0,2.0*math.pi) gate = qt.Qobj(qt.phasegate(delta)*qt.rz(alpha)*qt.ry(theta)*qt.rz(beta)) if value == True: gate = gate *qt.Qobj([[0,1],[1,0]]) else: gate = gate return gate
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 ry(self, angle: float) -> None: self.parent._apply(qt.ry(angle), [self.qubit_id]) # <3>
def main(): pop = input("How many of each gate do you want to populate? ") pop = int(pop) split = input( "Give training set split, in the form of a number between 0 and 1: ") k = input("Give a k value: ") k = int(k) d = input("Gimme a range of reference states: ") d = int(d) qubits = 3 n = 2**qubits csvpath = [ "WTrainingData2000new.csv", "WTrainingData2000QFT.csv", "WTrainingData2000Had.csv", "WTrainingData2000QFT2.csv" ] r1 = tensor_fix(qt.tensor(qt.ry(-1.23096), id2)) r1 = tensor_fix(qt.tensor(r1, id2)) r2 = tensor_fix(qt.tensor(qt.ry(np.pi / 4), id2)) r2 = tensor_fix(qt.tensor(r2, id2)) r3 = tensor_fix(qt.tensor(qt.ry(-1 * np.pi / 4), id2)) r3 = tensor_fix(qt.tensor(r3, id2)) state_creator = [ r1, paulix(3, 1), paulix(3, 2), qt.cnot(3, 0, 1), r2, qt.cnot(3, 1, 0), r3, paulix(3, 0), paulix(3, 1), qt.cnot(3, 0, 2), qt.cnot(3, 1, 2) ] state_creator_tags = [ "Rotation", "X", "X2", "CNOT", "Rotation2", "CNOT2", "Rotation3", "X3", "X4", "CNOT3", "CNOT4" ] circuit = [] angles = [] for i in range(len(state_creator)): circuit.append(state_creator[i]) circuit.append(state_creator_tags[i]) cat = categorize(circuit) alt = [] angles = [] for i in range(len(circuit)): if type(circuit[i]) == str: continue else: alt.append(gate_troubleshooter(circuit[i], n)) choice = [2, 4, 5, 6] vector_name = ['new', 'QFT', 'Hadamard 2', 'Fourier State'] index = 0 for x in choice: choice = x path = csvpath[index] vectors = gen_basis_vectors(n, n, choice) print(vector_name[index]) index = index + 1 probs = alter_wcirc(alt, angles, vectors, pop, cat, qubits, d, path) KNN(probs, split, k) return 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 main(): d = 4 qubits = 2 n = 2**qubits th = uniform(0, 2 * np.pi) rotate = tensor_fix(qt.tensor(id2, qt.ry(th))) rotate = tensor_fix(qt.tensor(rotate, id2)) """ state_creator=[rotate*hadamaker(qubits,[1]),qt.cnot(qubits,1,2),qt.cnot(qubits,0,1),hadamaker(qubits,[0]),qt.cnot(qubits,1,2),conv_cz()] state_creator_tags=["Hadamard","CNOT","CNOT2","Hadamard2","CNOT3","Control Z"] circuit=[] for i in range(len(state_creator)): circuit.append(state_creator[i]) circuit.append(state_creator_tags[i]) alt=[] for i in range(len(circuit)): if type(circuit[i]) == str: continue else: alt.append(gate_troubleshooter(circuit[i],n)) """ ghzcirc = [hadamaker(qubits, [0]), qt.cnot(qubits, 0, 1)] ghz_tags = ["Hadamard", "CNOT"] circuit = [] for i in range(len(ghzcirc)): circuit.append(ghzcirc[i]) circuit.append(ghz_tags[i]) #cat=categorize(circuit) alt = [] #angles=[] for i in range(len(circuit)): if type(circuit[i]) == str: continue else: alt.append(gate_troubleshooter(circuit[i], n)) choice = [2, 4, 5, 6] vector_name = ['new', 'QFT', 'Hadamard 2', 'Fourier State'] #ideals=[] tolerance = input("Give a tolerance: ") tolerance = float(tolerance) vectors = gen_basis_vectors(n, n, 5) ideal = get_ideal(alt, vectors, qubits, d) print(vector_name[i]) print(ideal[0]) ideal = [ 0.7803300858899107, 0.7803300858899107, 0.7803300858899107, 0.7803300858899107 ] #ideals.append(ideal[0]) path = input( "Give csv file location, remembering to use forward slashes: ") KNN(path, 0.8, 5, tolerance, ideal) """ tolerance=0.9 for i in range(10): multi=uniform(0,1) ideal2=ideal[0] probvector=[] for x in range(len(ideal2)): probvector.append(multi*ideal2[x]) truth=within_tolerance(tolerance,probvector,ideal[0]) print(multi) print(truth) """ return 0
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 RY(self, target, theta): self.state = ry(theta, self.qubits, self.qubits - 1 - target) * self.state
def ry(self, theta : float) -> None: self.parent._apply(qt.ry(theta), self.qubit_id)
def as_qobj_operator(self, instance: "GateInstance") -> qutip.Qobj: return qutip.ry(instance.params[0])
def ry(self, theta: float) -> None: self.state = qt.ry(theta) * self.state
#testing witnesses and cost functions for GHZ states f1 = gen_F1_graph(N_test, edges_test) f2 = gen_F2_graph(N_test, edges_test) f = gen_proj_graph_state(N_test, edges_test) ev1 = assert_and_recast_to_real(np.linalg.eigvals((f1-f).full())) ev2 = assert_and_recast_to_real(np.linalg.eigvals((f2-f).full())) assert np.all(ev1 <= 1e-6), "fom1 should be <= f" assert np.all(ev2 <= 1e-6), "fom2 should be <= f" assert np.allclose(np.max(ev1),0), "there should be at least one 0 e.v. (corresponding to the target state)" assert np.allclose(np.max(ev2),0), "there should be at least one 0 e.v. (corresponding to the target state)" # nb_q = 6 x_rdm = np.array([1.70386471,1.38266762,3.4257722,5.78064,3.84102323,2.37653078]) init = qt.tensor(*[zero]*nb_q) rot_init = qt.tensor(*[qt.ry(N=1, phi=x) for n,x in enumerate(x_rdm)]) cz = [cphase(np.pi, nb_q, c, t) for c, t in edges_test] entangl = prod_listop(cz) fin = entangl * rot_init * init qt.expect(f, fin) qt.expect(f1, fin) qt.expect(f2, fin) exp_stab = [qt.expect(s, fin) for s in list_stab] N_test = 6 edges_test = [[i, i+1]for i in range(N_test-1)] + [[N_test-1, 0]] graph_test = gen_graph_state(N=N_test, edges=edges_test) #gen_decomposition_paulibasis(graph_test, N = N_test, threshold=1e-6, symbolic=True)
def CO_ry(Chromosome, phase=np.pi / 8): return np.dot(Chromosome, np.array(qc.ry(phase).full()))
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 Ry(angle): return qt.ry(angle)