def get_probs(self, t1, t2): prog = new_circuit() prog = add_decoherence_noise(prog, T1=t1, T2=t2) #result = self.qvm.run_and_measure(prog, [0,1,2,3,4,5,6,7], trials=100000) #print(len(result)) #print(result.count([0]*(2**3)) ) print('Hola')
def add_noise_to_program(prog, T1=30e-6, T2=30e-6, gate_time_1q=50e-9, gate_time_2q=150e-09, ro_fidelity=0.95): """ Add generic damping and dephasing noise to a program. .. warning:: This function is deprecated. Please use :py:func:`add_decoherence_noise` instead. :param prog: A pyquil program consisting of I, RZ, CZ, and RX(+-pi/2) instructions :param Union[Dict[int,float],float] T1: The T1 amplitude damping time either globally or in a dictionary indexed by qubit id. By default, this is 30 us. :param Union[Dict[int,float],float] T2: The T2 dephasing time either globally or in a dictionary indexed by qubit id. By default, this is also 30 us. :param float gate_time_1q: The duration of the one-qubit gates, namely RX(+pi/2) and RX(-pi/2). By default, this is 50 ns. :param float gate_time_2q: The duration of the two-qubit gates, namely CZ. By default, this is 150 ns. :param Union[Dict[int,float],float] ro_fidelity: The readout assignment fidelity :math:`F = (p(0|0) + p(1|1))/2` either globally or in a dictionary indexed by qubit id. :return: A new program with noisy operators. """ warnings.warn( "pyquil.kraus.add_noise_to_program is deprecated, please use " "pyquil.noise.add_decoherence_noise instead.", DeprecationWarning) return add_decoherence_noise(prog, T1=T1, T2=T2, gate_time_1q=gate_time_1q, gate_time_2q=gate_time_2q, ro_fidelity=ro_fidelity)
def test_decoherence_noise(): prog = Program(RX(np.pi / 2, 0), CZ(0, 1), RZ(np.pi, 0)) gates = _get_program_gates(prog) m1 = _decoherence_noise_model(gates, T1=INFINITY, T2=INFINITY, ro_fidelity=1.) # with no readout error, assignment_probs = identity matrix assert np.allclose(m1.assignment_probs[0], np.eye(2)) assert np.allclose(m1.assignment_probs[1], np.eye(2)) for g in m1.gates: # with infinite coherence time all kraus maps should only have a single, unitary kraus op assert len(g.kraus_ops) == 1 k0, = g.kraus_ops # check unitarity k0dk0 = k0.dot(k0.conjugate().transpose()) assert np.allclose(k0dk0, np.eye(k0dk0.shape[0])) # verify that selective (by qubit) dephasing and readout infidelity is working m2 = _decoherence_noise_model(gates, T1=INFINITY, T2={0: 30e-6}, ro_fidelity={ 0: .95, 1: 1.0 }) assert np.allclose(m2.assignment_probs[0], [[.95, 0.05], [.05, .95]]) assert np.allclose(m2.assignment_probs[1], np.eye(2)) for g in m2.gates: if 0 in g.targets: # single dephasing (no damping) channel on qc 0, no noise on qc1 -> 2 Kraus ops assert len(g.kraus_ops) == 2 else: assert len(g.kraus_ops) == 1 # verify that combined T1 and T2 will lead to 4 outcome Kraus map. m3 = _decoherence_noise_model(gates, T1={0: 30e-6}, T2={0: 30e-6}) for g in m3.gates: if 0 in g.targets: # damping (implies dephasing) channel on qc 0, no noise on qc1 -> 4 Kraus ops assert len(g.kraus_ops) == 4 else: assert len(g.kraus_ops) == 1 # verify that gate names are translated new_prog = apply_noise_model(prog, m3) new_gates = _get_program_gates(new_prog) # check that headers have been embedded headers = _noise_model_program_header(m3) assert all( (isinstance(i, Pragma) and i.command in ["ADD-KRAUS", "READOUT-POVM"]) or isinstance(i, DefGate) for i in headers) assert headers.out() in new_prog.out() # verify that high-level add_decoherence_noise reproduces new_prog new_prog2 = add_decoherence_noise(prog, T1={0: 30e-6}, T2={0: 30e-6}) assert new_prog == new_prog2
def probabilities2(self, angles, t1, t2): prog = new_circuit() prog = add_decoherence_noise(prog, T1=t1, T2=t2) wf = self.qvm.wavefunction(prog) wf = wf.amplitudes.reshape((-1, 1)) probs = np.zeros_like(wf) for xx in range(2**self.n_qubits): probs[xx] = np.conj(wf[xx]) * wf[xx] return probs
def get_probs_grover(self, t1, t2): prog = new_circuit_grover3() prog = add_decoherence_noise(prog, T1=t1, T2=t2) #result = self.qvm.run_and_measure(prog, [0,1,2,3,4,5,6,7], trials=100000) #print(len(result)) #print(result.count([0]*(2**3)) ) wf = self.qvm.wavefunction(prog) wf = wf.amplitudes.reshape((-1, 1)) probs = np.zeros_like(wf) for xx in range(2**self.n_qubits): probs[xx] = np.conj(wf[xx]) * wf[xx] print(probs[0][0].real) return probs[0][0].real
def run_grovers(qc: str, N: int, begin: str, end: str, rounds=-1, offsets=[1, 0], trials=20, nlevel=0): print("Using qvm: " + qc) ret = {} for i in range(N): ret[i] = [] qvm = get_qc(qc, as_qvm=True) p = Program() ro = p.declare('ro', 'BIT', N) # Initialize Non-Ancillary QBits for i in range(N): p += H(i) # Main Loop Setup if rounds == -1: # Default number of rounds rounds = int(np.pi / 4 * np.sqrt(2**N)) print("Running for " + str(rounds) + " rounds") diff_def, diffusion_op = create_diffusion_op(N) p += diff_def oracle = make_shift_rows_oracle(begin, end, N, offsets) # Main Loop for r in range(rounds): p += oracle p += diffusion_op(*range(N)) # compile p = qvm.compile(p) p = Program(p.program) p = add_decoherence_noise(p, nlevel * 3e-5, nlevel * 3e-5, 5e-8, 1.5e-7, 1) p.pop() # Remoes HALT instruction for i in range(N): p += MEASURE(i, ro[i]) for n in range(trials): results = qvm.run(p)[0] for j in range(N): ret[j].append(results[j]) return ret
def run_with_gate_time_sampling(cxn: QVMConnection, programs: Iterable[Tuple[float, Program]], program_modifier=None, trials=20000): records = [] base = 50e-9 gate_times = np.array([1, 2, 3, 4]) * base for param, program in programs: program = program.copy() ro = program.declare('ro', 'BIT', 2) for gate_time in gate_times: noisy = add_decoherence_noise(program, gate_time_1q=gate_time, gate_time_2q=3 * gate_time).inst([ MEASURE(0, ro[0]), MEASURE(1, ro[1]), ]) if program_modifier: noisy = program_modifier(noisy) bitstring = np.array(cxn.run(noisy, [0, 1], trials)) z0, z1 = np.mean(bitstring, axis=0) zz = 1 - (np.sum(bitstring, axis=1) % 2).mean() * 2 f0, f1 = (trials - np.sum(bitstring, axis=0)) / trials ff = np.sum(np.sum(bitstring, axis=1) == 0) / trials record = { 'z0': z0, 'z1': z1, 'zz': zz, 'f0': f0, 'f1': f1, 'ff': ff, 'param': param, 'noise_param': gate_time, } records += [record] return records
def decoherence_noise_model(self): """ Adds the Rigetti decoherence noise model to the circuit The default noise parameters - T1 = 30 us T1 = 30e-6 - T2 = 30 us T2 = 30e-6 - 1q gate time = 50 ns gate_time_1q = 50e-9 - 2q gate time = 150 ns gate_time_2q = 150e-09 ro_fidelity = 0.95 """ [T1, T2, gate_time_1q, gate_time_2q, ro_fidelity] = self.noise_params self.circuit = add_decoherence_noise(self.circuit, T1=T1, T2=T2, gate_time_1q=gate_time_1q, gate_time_2q=gate_time_2q, ro_fidelity=ro_fidelity) return self.circuit
def add_dd(program: Program): new_program = program.copy_everything_except_instructions() counts = [0, 0] for gate in program: try: if len(gate.qubits) > 1: if abs(counts[0] - counts[1]) >= 2: min_ind = int(counts[0] > counts[1]) times = max(int(abs(counts[0] - counts[1]) / 4), 1) p = add_decoherence_noise( Program(get_dd_sec(min_ind) * times)) new_program.inst(p) counts = [0, 0] else: counts[gate.qubits[0].index] += 1 except AttributeError: pass new_program.inst(gate) return new_program
from pyquil.noise import add_decoherence_noise records = [] for theta in thetas: for t1 in t1s: prog = get_compiled_prog(theta) noisy = add_decoherence_noise(prog, T1=t1).inst([ MEASURE(0, 0), MEASURE(1, 1), ]) bitstrings = np.array(cxn.run(noisy, [0, 1], 1000))
def get_noisy_executable(qc: QuantumComputer, native_program: Program, noise_param: float): noisy = add_decoherence_noise(native_program, gate_time_1q=noise_param, gate_time_2q=3 * noise_param) return qc.compiler.native_quil_to_executable(noisy)
def runExperiments(t1, t2, ro_fidelity, q1time, q2time): global MSG_LENGTH NUM_TRIALS = 1 total_retries = 0 total_noise_fails = 0 qc = get_qc("9q-square-qvm") for trial in range(NUM_TRIALS): # perform secret sharing procedure once per message bit for i in range(MSG_LENGTH): while (True): # retry until success alice_q, bob_q, charlie_q, program = initial_setup() alice_measure_dir, program = alice(alice_q, program) bob_measure_dir, program = bob(bob_q, program) charlie_measure_dir, program = charlie(charlie_q, program) # run program with noise program = program.measure_all() program = qc.compiler.quil_to_native_quil(program) program = add_decoherence_noise(program, T1=t1, T2=t2, gate_time_1q=q1time, gate_time_2q=q2time, ro_fidelity=ro_fidelity) program.wrap_in_numshots_loop(1000) program = qc.compiler.native_quil_to_executable(program) results = qc.run(program) # check if measurements were in right direction should_abort = not check_directions( alice_measure_dir, bob_measure_dir, charlie_measure_dir) if should_abort: print( "Abort! Measurements yielded no useful information. Retrying..." ) total_retries += 1 continue for j in range(1000): curr_results = results[j] alice_measure_result = curr_results[0] bob_measure_result = curr_results[1] charlie_measure_result = curr_results[2] joint_result = bob_and_charlie(bob_measure_result, charlie_measure_result) if joint_result == alice_measure_result: print( "Success! Bob and Charlie reconstructed one bit of the secret message." ) else: print( "Failure! Bob and Charlie reconstructed an incorrect bit of the secret message." ) total_noise_fails += 1 break print("Total retries: %d" % total_retries) print("Total noise fails: %d" % total_noise_fails) return total_noise_fails