def test_create_program_graphs(): calib_time = datetime(year=2019, month=2, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc) qubit_list = [] ro_errors = [0.01, 0.01, 0.01] for ro_error in ro_errors: qubit_list.append(make_qubit_with_error(ro_error)) p01 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.9)] g01 = Gate(name="CX0_1", gate="cx", parameters=p01, qubits=[0, 1]) p12 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)] g12 = Gate(name="CX1_2", gate="cx", parameters=p12, qubits=[1, 2]) gate_list = [g01, g12] bprop = BackendProperties(last_update_date=calib_time, backend_name="test_backend", qubits=qubit_list, backend_version="1.0.0", gates=gate_list, general=[]) circ_list = [random_circuit(2, 10, measure=True), random_circuit( 4, 10, measure=True), random_circuit(3, 10, measure=True), random_circuit(5, 10, measure=True)] dag_list = [circuit_to_dag(circ) for circ in circ_list] caml = CrosstalkAdaptiveMultiLayout(bprop) num_q = caml._create_program_graphs(dag_list) print(num_q) heights = [] for dag in caml.dag_list: height = dag.num_qubits() heights.append(height) print(heights)
def test_simple_random(self): """Test creating a simple random circuit. """ circ = random_circuit(num_qubits=5, depth=4) self.assertIsInstance(circ, QuantumCircuit) self.assertEqual(circ.width(), 5) self.assertEqual(circ.depth(), 4)
def test_job(self): """Test retrieving a composite job.""" tags = ["test_job_set"] circs_counts = [3, 4] for count in circs_counts: with self.subTest(count=count): circs = [] for _ in range(count): circs.append(random_circuit(num_qubits=2, depth=3, measure=True)) circs = transpile(circs, backend=self.sim_backend) job_set = self.sim_backend.run( circs, max_circuits_per_job=2, job_tags=tags ) job_set.block_for_submit() self.assertEqual(job_set.tags(), tags) rjob_set = self.dependencies.provider.backend.job(job_set.job_id()) self.assertIsInstance(rjob_set, IBMCompositeJob) self.assertEqual(rjob_set.job_id(), job_set.job_id()) self.assertEqual(len(rjob_set.sub_jobs()), len(job_set.sub_jobs())) self.assertEqual( {rsub.job_id() for rsub in rjob_set.sub_jobs()}, {sub.job_id() for sub in job_set.sub_jobs()}, ) self.assertEqual(rjob_set.tags(), job_set.tags()) self.assertEqual( job_set.result().to_dict(), rjob_set.result().to_dict() ) job_circuits = job_set.circuits() rjob_circuits = rjob_set.circuits() self.assertEqual(len(job_circuits), count) self.assertEqual(len(job_circuits), len(rjob_circuits)) for job_circ, rjob_circ in zip(job_circuits, rjob_circuits): self.assertEqual(job_circ.data, rjob_circ.data)
def test_retry_failed_submit(self): """Test retrying failed job submit.""" max_circs = self.fake_backend.configuration().max_experiments circs = [] count = 3 for _ in range(max_circs * (count - 1) + 1): circs.append(random_circuit(num_qubits=2, depth=3, measure=True)) sub_tests = [[0], [1, 2], [0, 2]] for failed_index in sub_tests: with self.subTest(failed_index=failed_index): self._set_fake_client(JobSubmitFailClient(failed_indexes=failed_index)) job_set = self.fake_backend.run(circs) job_set.wait_for_final_state() self.assertEqual(job_set.status(), JobStatus.ERROR) good_indexes = set(range(count)) - set(failed_index) self.assertEqual(len(job_set.sub_jobs()), len(good_indexes)) good_ids = {job.job_id() for job in job_set.sub_jobs()} job_set.rerun_failed() job_set.wait_for_final_state() self.assertEqual(job_set.status(), JobStatus.DONE) self.assertEqual(len(job_set.sub_jobs()), count) self.assertTrue( good_ids.issubset({job.job_id() for job in job_set.sub_jobs()}) ) circ_idx = 0 for sub_job in job_set.sub_jobs(): for job_circ in sub_job.circuits(): self.assertEqual(job_circ, circs[circ_idx]) circ_idx += 1 self.assertEqual(job_set.circuits(), circs)
def growing_depth(n_qubits, n_circuits): circuits = [] circ = QuantumCircuit(n_qubits) for i in range(n_circuits): circ = random_circuit(n_qubits, 1, measure=False).combine(circ) circuits.append(circ) return circuits, n_circuits
def add_custom_instruction(self): backend = self.backend(max_job_size=1, max_shot_size=1) circ = random_circuit(num_qubits=2, depth=4) circ.save_statevector() circ = transpile(circ, backend) qobj = assemble(circ) split_qobj(qobj, max_size=1, max_shot_size=1, qobj_id='testing')
def test_random_circuits(self): for circuit_index in range(1000): num_qubits = random.randrange(1, 6) # Generate random circuit and transpile it to run on specific hardware random_circ = transpile( random_circuit(num_qubits, 5, measure=False), self.quac_simulator) random_circ.measure_all() # Get QuaC-calculated probabilities in a list plugin_probs = counts_to_dist( execute(random_circ, self.quac_simulator, shots=1, optimization_level=0, quac_noise_model=QuacNoiseModel.get_noiseless_model( 5)).result().get_counts()) # Get Qiskit-calculated probabilities in a list random_circ.remove_final_measurements( ) # avoid collapsing state vector qiskit_sv = execute( random_circ, self.qasm_simulator, shots=8000, optimization_level=0, ).result().get_statevector(random_circ) # qiskit_probs = qiskit_statevector_to_probabilities(qiskit_sv, 5) qiskit_probs = statevector_to_probabilities(qiskit_sv) # Calculate divergence of Qiskit and QuaC predictions difference_angle = get_vec_angle(qiskit_probs, plugin_probs) self.assertLess(difference_angle, 1e-5)
def test_random_measure(self): """Test random circuit with final measurement.""" num_qubits = depth = 3 circ = random_circuit(num_qubits, depth, measure=True) self.assertEqual(circ.width(), 2 * num_qubits) dag = circuit_to_dag(circ) for nd in list(dag.topological_op_nodes())[-num_qubits:]: self.assertIsInstance(nd.op, Measure)
def mutate(self, qc : QuantumCircuit): # Delete a gate if (random() < 0.75): qc.data.pop(randint(0, len(qc.data) - 1)) if (random() < 0.25): circ = random_circuit(qc.num_qubits, 1, measure=False) qc.append(circ.to_instruction(), qc.qregs) return qc
def generate_random_circuits(): """Generate multiple random circuits.""" random_circuits = [] for i in range(10): random_circuits.append( random_circuit(10, 10, measure=True, conditional=True, reset=True, seed=42 + i) ) return random_circuits
def test_split(self): """Circuits split test""" backend = self.backend(max_job_size=1) circs = [ random_circuit(num_qubits=2, depth=4, measure=True, seed=i) for i in range(2) ] circs = transpile(circs, backend) self.split_compare(circs, backend)
def test_huge_circuit(self): """Test draw huge circuit.""" filename = self._get_resource_path('test_huge.tex') qc = random_circuit(40, 40, 1) try: circuit_drawer(qc, filename=filename, output='latex_source') self.assertNotEqual(os.path.exists(filename), False) finally: if os.path.exists(filename): os.remove(filename)
def test_sub_job(self): """Test retrieving a single sub job.""" max_circs = 3 num_jobs = 3 circs = [] for _ in range(max_circs * (num_jobs - 1) + 1): circs.append(random_circuit(num_qubits=2, depth=3, measure=True)) job_set = self.fake_backend.run(circs, max_circuits_per_job=max_circs) job_set.block_for_submit() circ_idx = random.randint(0, len(circs) - 1) self.assertIn(circs[circ_idx], job_set.sub_job(circ_idx).circuits())
def test_job_circuits(self): """Test job circuits.""" circs = [] for _ in range(3): circs.append(random_circuit(num_qubits=2, depth=3, measure=True)) circs_copied = circs.copy() job_set = self.fake_backend.run(circs, max_circuits_per_job=1) job_circuits = job_set.circuits() self.assertEqual(job_circuits, circs_copied) for i, sub_job in enumerate(job_set.sub_jobs()): self.assertEqual(sub_job.circuits()[0], circs_copied[i])
def test_random_circuit_conditional_reset(self): """Test generating random circuits with conditional and reset.""" num_qubits = 1 depth = 100 circ = random_circuit(num_qubits, depth, conditional=True, reset=True, seed=5) self.assertEqual(circ.width(), 2 * num_qubits) self.assertIn("reset", circ.count_ops())
def prepare_circuits(backend): """Generate a random circuit. Args: backend (qiskit.providers.Backend): Backend used for transpilation. Returns: qiskit.QuantumCircuit: Generated circuit. """ circuit = random_circuit(num_qubits=5, depth=4, measure=True, seed=random.randint(0, 1000)) return transpile(circuit, backend)
def test_overcomplete_basis(self): """Test optimization with an overcomplete basis.""" circuit = random_circuit(3, 3, seed=42) basis = ["rz", "rxx", "rx", "ry", "p", "sx", "u", "cx"] passmanager = PassManager() passmanager.append(BasisTranslator(sel, basis)) basis_translated = passmanager.run(circuit) passmanager = PassManager() passmanager.append(Optimize1qGatesDecomposition(basis)) result_full = passmanager.run(basis_translated) self.assertTrue(Operator(circuit).equiv(Operator(result_full))) self.assertGreater(basis_translated.depth(), result_full.depth())
def test_multiple_circuits(self): """Test multiple circuits can be serialized together.""" circuits = [] for i in range(10): circuits.append( random_circuit(10, 10, measure=True, conditional=True, reset=True, seed=42 + i) ) qpy_file = io.BytesIO() dump(circuits, qpy_file) qpy_file.seek(0) new_circs = load(qpy_file) self.assertEqual(circuits, new_circs)
def test_execute(self, n_qubits, depth): circuit = random_circuit(n_qubits, depth, reset=True, measure=True, seed=0) transpiled = transpile(circuit, pass_manager=level_3_with_contant_pure( self.pm_conf)) expected = self.execute(circuit).result() result = self.execute(transpiled).result() self.assertEqualCounts(result, expected)
def generator( ): #This function generates random levels for Qflow based on user input rd.seed() #set seed for random numbers num_qubit = int(input('Enter the number of Qubits:') ) # take user input for number of qubits and depth. depth = int( input('Enter the circuit depth:')) # recomend 2 qubits for now. end = False # end while loop flag while end == False: Circ = random_circuit(num_qubit, depth) # Generate a random circuit Circ_Operator = Operator(Circ) #construct operator for the circuit Unitary = Circ_Operator.data # extract the unitary as a 2D array origin = np.zeros( 2**num_qubit) # define the origin vector of the state space state = np.zeros( 2** num_qubit) # create a random unnormalised state in the state space for i in range(len(state)): state[i] = rd.random() length = distance.euclidean(origin, state) state = state / length # normalise the state flow = np.zeros( (Unitary.shape[0], Unitary.shape[1])) # define empt flow matrix for n in range(Unitary.shape[0]): #fill flow matrix for m in range(Unitary.shape[1]): sum = 0 for i in range(Unitary.shape[1]): sum += state[i] * Unitary[n, i] flow[n, m] = ((state[m].conjugate()) * (Unitary[n, m].conjugate()) * sum).real if flow[n, m] < 0: # check that at least one element is negative and if true end the loop end = True valid = FlowCheck( Unitary, state, flow ) #Check that the generated matrix does indeed satisfy the required constraints using a second function. if valid == True: return Unitary, state, flow elif valid == False: print('An Error has occured restart the game.')
def test_repr_of_instructions(self): """Test the __repr__ method of the Instruction class""" ins1 = Instruction("test_instruction", 3, 5, [0, 1, 2, 3]) self.assertEqual( repr(ins1), "Instruction(name='{}', num_qubits={}, num_clbits={}, params={})". format(ins1.name, ins1.num_qubits, ins1.num_clbits, ins1.params), ) ins2 = random_circuit(num_qubits=4, depth=4, measure=True).to_instruction() self.assertEqual( repr(ins2), "Instruction(name='{}', num_qubits={}, num_clbits={}, params={})". format(ins2.name, ins2.num_qubits, ins2.num_clbits, ins2.params), )
def test_run(): IBMQ.load_account() provider = IBMQ.get_provider( hub='ibm-q-keio', group='keio-internal', project='keio-students') backend = provider.get_backend("ibmq_toronto") calib_time = datetime(year=2020, month=8, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc) bprop = backend.properties(datetime=calib_time) circ = random_circuit(10, 3, measure=True, seed=1) circ = decompose_to_base_gates(circ) print(circ) dag = circuit_to_dag(circ) caml = CrosstalkAdaptiveMultiLayout(bprop) caml.run(dag) pprint(caml.property_set['layout'])
def test_run_with_Xtalk(): calib_time = datetime(year=2019, month=2, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc) qubit_list = [] ro_errors = [0.01]*6 for ro_error in ro_errors: qubit_list.append(make_qubit_with_error(ro_error)) p01 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)] p03 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.3)] p12 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.3)] p14 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.2)] p35 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.3)] p45 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)] p25 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)] g01 = Gate(name="CX0_1", gate="cx", parameters=p01, qubits=[0, 1]) g03 = Gate(name="CX0_3", gate="cx", parameters=p03, qubits=[0, 3]) g12 = Gate(name="CX1_2", gate="cx", parameters=p12, qubits=[1, 2]) g14 = Gate(name="CX1_4", gate="cx", parameters=p14, qubits=[1, 4]) g35 = Gate(name="CX3_5", gate="cx", parameters=p35, qubits=[3, 5]) g45 = Gate(name="CX4_5", gate="cx", parameters=p45, qubits=[4, 5]) g25 = Gate(name="CX2_5", gate="cx", parameters=p25, qubits=[2, 5]) gate_list = [g01, g03, g12, g14, g35, g45, g25] bprop = BackendProperties( last_update_date=calib_time, backend_name="test_backend", qubits=qubit_list, backend_version="1.0.0", gates=gate_list, general=[]) xtalk_prop = {(2, 5): {(0, 1): 5}, (1, 0): {(2, 5): 5}, } circ = random_circuit(6, 3, measure=True, seed=1) circ = decompose_to_base_gates(circ) print(circ) dag = circuit_to_dag(circ) caml_noXtalk = CrosstalkAdaptiveMultiLayout(bprop) caml_noXtalk.run(dag) pprint(caml_noXtalk.property_set['layout']) caml_Xtalk = CrosstalkAdaptiveMultiLayout(bprop, crosstalk_prop=xtalk_prop) caml_Xtalk.run(dag) pprint(caml_Xtalk.property_set['layout'])
def test_noise_model_to_and_from_array(self): random_circs = [random_circuit(5, 5, measure=True) for _ in range(100)] true_t1 = [1000 * (1 + random.random()) for _ in range(5)] true_t2 = [10000 * (1 + random.random()) for _ in range(5)] # Develop random measurement matrices for each qubit of the form # [ P(0|0) P(0|1) ] # [ P(1|0) P(1|1) ] meas_mats = [] for _ in range(5): stay_zero = random.random() stay_one = random.random() meas_mats.append( np.array([ [stay_zero, 1 - stay_one], [1 - stay_zero, stay_one] ]) ) zz = {} for qubit1 in range(5): for qubit2 in range(5): if qubit1 != qubit2: zz[(qubit1, qubit2)] = random.randrange(1, 10) * 1e-5 random_quac_noise_model = QuacNoiseModel( true_t1, true_t2, [meas_mats[0] for _ in range(5)], None ) recovered_quac_noise_model = QuacNoiseModel.from_array(random_quac_noise_model.to_array(), 5) for circ in random_circs: transpiled_circ = transpile(circ, self.quac_sim, optimization_level=0) dist_original = execute(transpiled_circ, self.quac_sim, quac_noise_model=random_quac_noise_model, optimization_level=0).result().get_counts() dist_recovered = execute(transpiled_circ, self.quac_sim, quac_noise_model=recovered_quac_noise_model, optimization_level=0).result().get_counts() self.assertEqual(dist_original, dist_recovered)
def test_retry_failed_jobs(self): """Test retrying failed jobs.""" max_circs = 3 num_jobs = 3 circs = [] for _ in range(max_circs * (num_jobs - 1) + 1): circs.append(random_circuit(num_qubits=2, depth=3, measure=True)) sub_tests = [ [FailedFakeJob, BaseFakeJob, BaseFakeJob], [BaseFakeJob, FailedFakeJob, CancelableFakeJob], [CancelableFakeJob, BaseFakeJob, FailedFakeJob], ] for job_class in sub_tests: with self.subTest(job_class=job_class): self._set_fake_client(BaseFakeAccountClient(job_class=job_class)) job_set = self.fake_backend.run(circs, max_circuits_per_job=max_circs) time.sleep(3) for subjob in job_set.sub_jobs(): if subjob.status() == JobStatus.RUNNING: subjob.cancel() job_set.wait_for_final_state() self.assertEqual(job_set.status(), JobStatus.ERROR) good_ids = { job.job_id() for job in job_set.sub_jobs() if job.status() == JobStatus.DONE } job_set.rerun_failed() job_set.wait_for_final_state() self.assertEqual(job_set.status(), JobStatus.DONE) self.assertEqual(len(job_set.sub_jobs()), num_jobs) self.assertTrue( good_ids.issubset({job.job_id() for job in job_set.sub_jobs()}) ) circ_idx = 0 for sub_job in job_set.sub_jobs(): for job_circ in sub_job.circuits(): self.assertEqual(job_circ, circs[circ_idx]) circ_idx += 1 self.assertEqual(job_set.circuits(), circs)
def run_random_circuits(backend, shots=None, **run_options): """Test random circuits on different executor fictures""" job_size = 10 circuits = [ random_circuit(num_qubits=2, depth=2, seed=i) for i in range(job_size) ] # Sample references counts targets = [] for circ in circuits: state = Statevector(circ) state.seed = 101 targets.append(state.sample_counts(shots=shots)) # Add measurements for simulation for circ in circuits: circ.measure_all() circuits = transpile(circuits, backend) job = backend.run(circuits, shots=shots, **run_options) result = job.result() return result, circuits, targets
def test_initialize_backend_prop(): circ_list = [random_circuit(2, 2) for _ in range(10)] dag_list = [circuit_to_dag(circ) for circ in circ_list] calib_time = datetime(year=2019, month=2, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc) qubit_list = [] ro_errors = [0.01, 0.01, 0.01] for ro_error in ro_errors: qubit_list.append(make_qubit_with_error(ro_error)) p01 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.9)] g01 = Gate(name="CX0_1", gate="cx", parameters=p01, qubits=[0, 1]) p12 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)] g12 = Gate(name="CX1_2", gate="cx", parameters=p12, qubits=[1, 2]) gate_list = [g01, g12] bprop = BackendProperties(last_update_date=calib_time, backend_name="test_backend", qubits=qubit_list, backend_version="1.0.0", gates=gate_list, general=[]) caml = CrosstalkAdaptiveMultiLayout(bprop) caml._initialize_backend_prop()
def generate( self, num_multi_circ: int, num_circ: Union[int, List[int]], circ_size: Optional[Union[Tuple[int], List[Tuple[int]], List[List[Tuple[int]]]]] = None, seed: Optional[Union[int, List[int], List[List[int]]]] = None, ): """ Args: num_multi_circ : number of multi-tasking circuit you want to make num_circ : The number of circuits containd in the multi-tasking circuit circ_size : width and depth of random circuit [w, d] random_seed : seed to make random circuit Return: The list of multi-circuit set or just single multi-circuit set multi-circuit set: the list of qc to make multi-tasking circuit """ multi_circuits_list = [] num_circ_list = self.parse_num_circ(num_circ) circ_size = self.parse_circ_size(circ_size, num_circ_list) seed_list_list = self.parse_seed(seed, num_circ_list) for mqc_id, num_circ in enumerate(num_circ_list): rand_qc_list = [] for qc_id in range(num_circ): width = circ_size[mqc_id][qc_id][0] depth = circ_size[mqc_id][qc_id][1] seed = seed_list_list[mqc_id][qc_id] rand_qc = random_circuit(width, depth, measure=True, seed=seed) rand_qc_list.append(rand_qc) multi_circuits_list.append(rand_qc_list) if num_multi_circ == 1: return multi_circuits_list[0] return multi_circuits_list
logging.basicConfig(level=logging.DEBUG) """ WARNING: seems not work on server, reasons unknown yet """ # import pdb # pdb.set_trace() provider = IBMQ.load_account() backend = provider.get_backend('ibmqx2') # Build a thousand circuits. circs = [] for _ in range(1000): circs.append(random_circuit(num_qubits=2, depth=3, measure=True)) # Need to transpile the circuits first. circs = transpile(circs, backend=backend) print('here1') # Use Job Manager to break the circuits into multiple jobs. job_manager = IBMQJobManager() job_set_foo = job_manager.run(circs, backend=backend, name='foo') print('here2') results = job_set_foo.results() results.get_counts(5) # Counts for experiment 5.
def test_random_depth_0(self): """Test random depth 0 circuit. """ circ = random_circuit(num_qubits=1, depth=0) self.assertEqual(circ.width(), 1) self.assertEqual(circ.depth(), 0)