def main(): qr, qc, crx, crz = setup() # initialize state to teleport vector_to_teleport = random_statevector(2) qc = initialize_teleport_state(qc, tel_qbit=TELEPORT_QBIT, state=vector_to_teleport.data) qc.barrier() # craete bell pair, as q1 and q2 where q1 shared with Alice and q2 with Bob qc = create_bell_pair(qc, a=A_QBIT, b=B_QBIT) # find i, j value (which bell states craetes pair q0 and q1 together), i is related to state (q0) and # j to Alice's entangeletn quibit q1 qc.barrier() qc = alice_bell_measurement(qc, psi=TELEPORT_QBIT, a=A_QBIT) qc.barrier() # evaluate bell measurment of Alice's total state # measured values are stored in crz and crx qc = measure_and_send(qc, a=TELEPORT_QBIT, b=A_QBIT, bit_a=0, bit_b=1) # apply gates regards to teleportation protocol theory qc.barrier() qc, crz, crx = bob_gates(qc, B_QBIT, crz=crz, crx=crx) plot_teleport_state_vector(vector_to_teleport.data) out_vector = q.execute(qc, STATE_VECTOR_BACKEND).result().get_statevector() plot_bloch_multivector(out_vector) # qc.draw("mpl") plt.show()
def get_state_fidelity(self, ori_circ, new_circ): num_qubits = ori_circ.num_qubits num_test = 10 fid_all = 0 for i in range(num_test): qc_ori = QuantumCircuit(num_qubits, num_qubits) qc_new = QuantumCircuit(num_qubits, num_qubits) init_state = random_statevector(2**num_qubits, np.random.randint(2000000)) qc_ori.initialize(init_state.data, range(num_qubits)) qc_new.initialize(init_state.data, range(num_qubits)) qc_ori.compose(ori_circ, inplace=True) qc_new.compose(new_circ, inplace=True) backend = Aer.get_backend('statevector_simulator') ori_job = execute(qc_ori, backend) state_ori = ori_job.result().get_statevector(qc_ori) new_job = execute(qc_new, backend) state_new = new_job.result().get_statevector(qc_new) fid = qk.quantum_info.state_fidelity(state_ori, state_new) fid_all += fid return fid_all / num_test
def test_set_statevector(self, num_qubits): """Test SetStatevector for instruction""" SUPPORTED_METHODS = [ 'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust', 'matrix_product_state' ] seed = 100 save_label = 'state' target = qi.random_statevector(2 ** num_qubits, seed=seed) circ = QuantumCircuit(num_qubits) circ.set_statevector(target) circ.save_statevector(label=save_label) # Run opts = self.BACKEND_OPTS.copy() qobj = assemble(circ, self.SIMULATOR) result = self.SIMULATOR.run(qobj, **opts).result() method = opts.get('method', 'automatic') if method not in SUPPORTED_METHODS: self.assertFalse(result.success) else: self.assertTrue(result.success) data = result.data(0) self.assertIn(save_label, data) value = qi.Statevector(result.data(0)[save_label]) self.assertAlmostEqual(value, target)
def main(): L = [i for i in range(1, 11)] print('Considering {} layers'.format(L)) #need a vector of random numbers that is normalized to 1, #easiest way to just take function from qiskit vec = random_statevector(16) epsilon = [] for l in L: #define random phi #scipy minimize wants a vector not array theta = np.random.rand(l * 2 * 4) * np.pi * 2 res = minimize(norm, theta, args=(vec, l), method='BFGS', options={ 'disp': True, 'maxiter': 1000 }) epsilon.append(norm(res.x, vec, l)) print(epsilon) plt.plot(L, epsilon, 'd-') plt.xlabel('layers L', fontsize=14) plt.ylabel('epsilon', fontsize=14) plt.xticks(fontsize=12) plt.yticks(fontsize=12) plt.ylim([0, 0.75]) plt.savefig('epsilon.eps')
def test_full_qst(self, num_qubits, fitter): """Test 1-qubit QST experiment""" backend = AerSimulator(seed_simulator=9000) seed = 1234 f_threshold = 0.95 target = qi.random_statevector(2**num_qubits, seed=seed) qstexp = StateTomography(target) if fitter: qstexp.analysis.set_options(fitter=fitter) expdata = qstexp.run(backend) results = expdata.analysis_results() # Check state is density matrix state = filter_results(results, "state").value self.assertTrue(isinstance(state, qi.DensityMatrix), msg="fitted state is not density matrix") # Check fit state fidelity fid = filter_results(results, "state_fidelity").value self.assertGreater(fid, f_threshold, msg="fit fidelity is low") # Manually check fidelity target_fid = qi.state_fidelity(state, target, validate=False) self.assertAlmostEqual(fid, target_fid, places=6, msg="result fidelity is incorrect")
def test_local_pbasis_default_statevector(self): """Test default states kwarg""" default_states = [qi.random_statevector(2, seed=30 + i) for i in range(3)] basis = LocalPreparationBasis("fitter_basis", default_states=default_states) for i, state in enumerate(default_states): basis_state = qi.DensityMatrix(basis.matrix([i], [0])) fid = qi.state_fidelity(state, basis_state) self.assertTrue(isclose(fid, 1))
def test_statevector_evolve(self): orig = qi.random_statevector(2, seed=10) compat = cqi.Statevector(orig.data) orig_op = qi.random_unitary(2, seed=10) compat_op = cqi.Operator(orig_op.data) target = orig.evolve(orig_op) self.assertEqual(orig.evolve(compat_op), target) self.assertEqual(compat.evolve(orig_op), target) self.assertEqual(compat.evolve(compat_op), target)
def test_local_pbasis_qubit_states_no_default(self): """Test matrix method raises for invalid qubit with no default states""" size = 2 qubits = [0, 2] qubit_states = { qubits[0]: [qi.random_density_matrix(2, seed=30 + i) for i in range(size)], qubits[1]: [qi.random_statevector(2, seed=40 + i) for i in range(size)], } basis = LocalPreparationBasis("fitter_basis", qubit_states=qubit_states) # No default states so should raise an exception with self.assertRaises(ValueError): basis.matrix([0, 0], [0, 1])
def test_local_mbasis_default_statevector(self): """Test default povms kwarg""" size = 2 outcomes = 3 default_povms = [ [qi.random_statevector(2, seed=30 + i + j) for j in range(outcomes)] for i in range(size) ] basis = LocalMeasurementBasis("fitter_basis", default_povms=default_povms) for i, povm in enumerate(default_povms): for outcome, effect in enumerate(povm): basis_state = qi.DensityMatrix(basis.matrix([i], outcome, [0])) fid = qi.state_fidelity(effect, basis_state) self.assertTrue(isclose(fid, 1))
def generate_random_psi(num_qbits=2, debug=False): """ Initialize our target state |psi> :param num_qbits: int, number of qbits :param debug: bool, will print |psi> :return: qiskit.quantum_info Statevector object """ dim = 2**num_qbits psi = random_statevector(dim, seed=random_seed) if debug: print(psi) return psi
def test_local_pbasis_default_and_qubit_states(self): """Test qubit states kwarg""" size = 3 qubits = [2, 0] default_states = [qi.random_density_matrix(2, seed=20 + i) for i in range(size)] qubit_states = {2: [qi.random_statevector(2, seed=40 + i) for i in range(size)]} basis = LocalPreparationBasis( "fitter_basis", default_states=default_states, qubit_states=qubit_states ) # Check states indices = it.product(range(size), repeat=2) states0 = qubit_states[qubits[0]] if qubits[0] in qubit_states else default_states states1 = qubit_states[qubits[1]] if qubits[1] in qubit_states else default_states for index in indices: basis_state = qi.DensityMatrix(basis.matrix(index, qubits)) target = qi.DensityMatrix(states0[index[0]]).expand(states1[index[1]]) fid = qi.state_fidelity(basis_state, target) self.assertTrue(isclose(fid, 1))
def test_local_pbasis_qubit_states(self): """Test qubit states kwarg""" size = 3 qubits = [0, 2] qubit_states = { qubits[0]: [qi.random_density_matrix(2, seed=30 + i) for i in range(size)], qubits[1]: [qi.random_statevector(2, seed=40 + i) for i in range(size)], } basis = LocalPreparationBasis("fitter_basis", qubit_states=qubit_states) # Check states indices = it.product(range(size), repeat=2) for index in indices: basis_state = qi.DensityMatrix(basis.matrix(index, qubits)) target0 = qi.DensityMatrix(qubit_states[qubits[0]][index[0]]) target1 = qi.DensityMatrix(qubit_states[qubits[1]][index[1]]) target = target0.expand(target1) fid = qi.state_fidelity(basis_state, target) self.assertTrue(isclose(fid, 1))
def test_full_qst(self, num_qubits): """Test QST experiment""" seed = 1234 shots = 5000 f_threshold = 0.99 # Generate tomography data without analysis backend = AerSimulator(seed_simulator=seed, shots=shots) target = qi.random_statevector(2**num_qubits, seed=seed) exp = StateTomography(target) expdata = exp.run(backend, analysis=None) self.assertExperimentDone(expdata) # Run each tomography fitter analysis as a subtest so # we don't have to re-run simulation data for each fitter for fitter in FITTERS: with self.subTest(fitter=fitter): if fitter: exp.analysis.set_options(fitter=fitter) fitdata = exp.analysis.run(expdata) self.assertExperimentDone(fitdata) results = expdata.analysis_results() # Check state is density matrix state = filter_results(results, "state").value self.assertTrue( isinstance(state, qi.DensityMatrix), msg=f"{fitter} fitted state is not density matrix", ) # Check fit state fidelity fid = filter_results(results, "state_fidelity").value self.assertGreater(fid, f_threshold, msg=f"{fitter} fit fidelity is low") # Manually check fidelity target_fid = qi.state_fidelity(state, target, validate=False) self.assertAlmostEqual( fid, target_fid, places=6, msg=f"{fitter} result fidelity is incorrect")
def update_configs(self, opt_config: Dict[str, Any], circ_config: Dict[str, Any]) -> None: """ If continuing from previous run, it will update the configs with previous values and ignore current ones. Update is done in place. """ if self.result is None: # If no previous run then generate random target state state = random_statevector(2**circ_config['nqubit']) else: state = Statevector(self.result['target_state']) opt_config['precision'] = self.result.get('error_precision', opt_config['precision']) opt_config['max_iter'] = self.result.get('max_iter', opt_config['max_iter']) opt_config['error_convergence'] = self.result.get( 'error_convergence', opt_config['error_convergence']) circ_config['nqubit'] = self.result.get('nqubit', circ_config['nqubit']) circ_config.update({'target_state': state})
def test_set_statevector(self, method, device, num_qubits): """Test SetStatevector for instruction""" backend = self.backend(method=method, device=device) seed = 100 label = 'state' target = qi.random_statevector(2**num_qubits, seed=seed) circ = QuantumCircuit(num_qubits) circ.set_statevector(target) circ.save_statevector(label=label) # Run result = backend.run(transpile(circ, backend, optimization_level=0), shots=1).result() self.assertTrue(result.success) simdata = result.data(0) self.assertIn(label, simdata) value = simdata[label] self.assertEqual(value, target)
def test_local_mbasis_default_and_qubit_states(self): """Test qubit and default povm kwarg""" size = 3 outcomes = 2 qubits = [2, 0] default_povms = ( [ [qi.random_statevector(2, seed=20 + i + j) for i in range(outcomes)] for j in range(size) ], ) qubit_povms = { qubits[0]: [ [qi.random_density_matrix(2, seed=30 + i + j) for i in range(outcomes)] for j in range(size) ], qubits[1]: [ [qi.random_density_matrix(2, seed=40 + i + j) for i in range(outcomes)] for j in range(size) ], } basis = LocalMeasurementBasis( "fitter_basis", default_povms=default_povms, qubit_povms=qubit_povms ) # Check states states0 = qubit_povms[qubits[0]] if qubits[0] in qubit_povms else default_povms states1 = qubit_povms[qubits[1]] if qubits[1] in qubit_povms else default_povms indices = it.product(range(size), repeat=2) outcomes = it.product(range(outcomes), repeat=len(qubits)) for index in indices: for outcome in outcomes: basis_state = qi.DensityMatrix( basis.matrix(index, self._outcome_tup_to_int(outcome), qubits) ) target0 = qi.DensityMatrix(states0[index[0]][outcome[0]]) target1 = qi.DensityMatrix(states1[index[1]][outcome[1]]) target = target0.expand(target1) fid = qi.state_fidelity(basis_state, target) self.assertTrue(isclose(fid, 1))
def main(): # Parse all command line arguments args = parser.parse_args() maxL = args.maxL minL = args.minL outfile = args.outfile odd_gates = args.odd even_gates = args.even seed = args.seed logfile = args.logfile verbose = args.verbose iterations = args.iterations # Define the logger logger = logging.getLogger('task1') if logfile: logger.addHandler(logging.FileHandler(logfile)) if verbose: logger.addHandler(logging.StreamHandler()) logger.setLevel(logging.DEBUG) np.random.seed(seed=seed) backend = Aer.get_backend('statevector_simulator') for i in range(iterations): random_vector = random_statevector(dims=(2, 2, 2, 2), seed=seed) for j in range(minL, maxL + 1): circuit = build_circuit(j, odd_gates=odd_gates, even_gates=even_gates) res = optimize.minimize( fun=objective_function, x0=np.random.rand(len(circuit.parameters)) * 2 * np.pi, args=(circuit, random_vector, backend), jac='2-point', bounds=[(0, 2 * np.pi)] * len(circuit.parameters), callback=lambda v: v % (2 * np.pi)) logger.debug(f'Iteration: {i + 1}') logger.debug(f'Goal statevector: {random_vector.data}') logger.debug(f'Number of layers: {j}') logger.debug(f'Odd gates: {odd_gates}') logger.debug(f'Even gates: {even_gates}') logger.debug(circuit.decompose()) logger.debug('\nResult') logger.debug( '====================================================================================' ) logger.debug(f'{res}') logger.debug( '====================================================================================\n' ) with open(outfile, 'a') as f: f.write(f'{i},{j},{res.fun}') f.write('\n') sys.exit(ExitStatus.success)
def test_roundtrip_statevector(self): """Test round-trip serialization of a Statevector""" obj = qi.random_statevector(4, seed=10) self.assertRoundTripSerializable(obj)
def test_statevector_tensor(self): orig = qi.random_statevector(2, seed=10) compat = cqi.Statevector(orig.data) target = orig.tensor(orig) self.assertEqual(compat.tensor(orig), target) self.assertEqual(orig.tensor(compat), target)
def test_statevector_linop(self): orig = qi.random_statevector(4, seed=10) compat = cqi.Statevector(orig.data) self.assertEqual(2 * compat - orig, orig) self.assertEqual(2 * orig - compat, orig)
def test_statevector_eq(self): orig = qi.random_statevector(4, seed=10) compat = cqi.Statevector(orig.data) self.assertEqual(compat, orig) self.assertEqual(orig, compat)
def test_unitary_evolve(self): orig = qi.random_unitary(2, seed=10) compat = cqi.Operator(orig.data) state = qi.random_statevector(2, seed=10) target = state.evolve(orig) self.assertEqual(state.evolve(compat), target)
def generate(self) -> list: b = [1, 0] sv1 = Statevector(random_statevector((2, 1))) sv2 = Statevector(random_statevector((2, 1))) return [[sv1.data, b], [sv2.data, b]]
def random_state(self): self.state = random_statevector(self.state.dim) self.original = self.state
def test_local_pbasis_no_inst(self): """Test circuits method raises if no instructions""" default_states = [qi.random_statevector(2, seed=30 + i) for i in range(2)] basis = LocalPreparationBasis("fitter_basis", default_states=default_states) with self.assertRaises(NotImplementedError): basis.circuit([0], [0])
qc.h(qr[a]) qc.measure(qr[a], crx) qc.measure(qr[b], crz) #Bobs transformation def bob_transformation(qc, qubit): qc.barrier() qc.x(qubit).c_if(crx, 1) qc.z(qubit).c_if(crz, 1) #note: bob's transformation may change depending upon the entanglement channel #creating a state that we want to teleport : alice will be the sender state = random_statevector(2, seed=3) state.probabilities() init_gate = Initialize(state.data) qc.append(init_gate, [0]) create_ent_channel(qc, 1, 2) bell_measurement(qc, 0, 1) bob_transformation(qc, 2) #qc.draw('mpl') #thus the bob qubit will be transformed to state which alice want to sent. #state of the alice's qubit get collapsed during the process '''#checking the bobs state backend=BasicAer.get_backend('statevector_simulator') in_state=state plot_bloch_multivector(in_state)'''
# Otherwise return the circuit and final vector (for tests and debugging) if optimise: return distance else: return distance, circuit, result_vector #Number of q-bits / c-bits n = 4 #Number of layers layers = [1, 2, 3, 4, 5] maxiter = 2000 #Random vector ref_vector = random_statevector(2**n).data # Setup output file f = open('output.txt', 'w') print('REFERENCE VECTOR', ref_vector, file=f) # Initialise list of distances vs layer number min_distance = [] for l in layers: # Initialise random angles between 0 and 2pi - angles for odd(even) blocks have odd(even) indices angle_random = 2 * pi * random.rand(2 * l, n) # Minimise cost function 'vec_stance' by optimising the angles of Rx and Rz gates res = optimize.minimize(vec_distance, angle_random, args=(n, l, ref_vector, True, False),