def hobo_qubo_mixer_measurement(hamildict, noise_model, angles, diag_vals, ps_end=False, mid_measure=None): n = int(np.max(hamildict[:, 1])) qr = QuantumRegister(n**2) main_circuit = QuantumCircuit(qr) times = len(angles) qubo_theta = angles[0:int(times / 2)] mixer_phi = angles[int(times / 2):] main_circuit += hadamards_position(n, qr) # Merging circuits for theta, phi in zip(qubo_theta, mixer_phi): main_circuit += hobo2qubo(n, qr) + qubo_circuit_simplified( hamildict, qr, theta) + hobo2qubo(n, qr).inverse() main_circuit += make_mixer(n, qr, phi) if mid_measure == 'no-ps': main_circuit += kraus_gates(qr, n, False) elif mid_measure == 'ps': main_circuit += kraus_gates(qr, n, True) else: pass if ps_end == 'end': main_circuit += kraus_gates(qr, n, True) main_circuit += hobo2qubo(n, qr) # Swap all for i in range(int(n**2 / 2)): main_circuit.swap(i, n**2 - 1 - i) #Preparation of Density-Matrix: backend = QasmSimulator(method='density_matrix', noise_model=noise_model, basis_gates=['cx', 'u1', 'u2', 'u3', 'kraus']) main_circuit.append(Snapshot('ss', 'density_matrix', n**2), qr) job = execute(main_circuit, backend=backend) result = job.result().results[0].to_dict( )['data']['snapshots']['density_matrix']['ss'][0]['value'] dm = np.asmatrix(result) #finds probability prob = np.trace(dm.real) #find mean energy mean_energy = np.real(np.sum(np.diag(dm) * diag_vals)) / prob max_energy = max(diag_vals) min_energy = min(diag_vals) energy = (mean_energy - min_energy) / (max_energy - min_energy) return energy, prob
def test_y_gate_deterministic_waltz_basis_gates(self): shots = 100 """Test y-gate gate circuits compiling to u1,u2,u3,cx""" circuits = ref_1q_clifford.y_gate_circuits_deterministic(final_measure=True) targets = ref_1q_clifford.y_gate_counts_deterministic(shots) job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx') result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0)
def test_conditional_2bit(self): """Test conditional operations on 2-bit conditional register.""" shots = 100 circuits = ref_conditionals.conditional_circuits_2bit(final_measure=True) targets = ref_conditionals.conditional_counts_2bit(shots) job = execute(circuits, QasmSimulator(), shots=shots) result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0)
def test_sdg_gate_nondeterministic_default_basis_gates(self): shots = 2000 """Test sdg-gate circuits compiling to backend default basis_gates.""" circuits = ref_1q_clifford.sdg_gate_circuits_nondeterministic(final_measure=True) targets = ref_1q_clifford.sdg_gate_counts_nondeterministic(shots) job = execute(circuits, QasmSimulator(), shots=shots) result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_cx_gate_nondeterministic_waltz_basis_gates(self): """Test cx-gate gate circuits compiling to u1,u2,u3,cx""" shots = 2000 circuits = ref_2q_clifford.cx_gate_circuits_nondeterministic(final_measure=True) targets = ref_2q_clifford.cx_gate_counts_nondeterministic(shots) job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx') result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_cz_gate_deterministic_minimal_basis_gates(self): """Test cz-gate gate circuits compiling to U,CX""" shots = 100 circuits = ref_2q_clifford.cz_gate_circuits_deterministic(final_measure=True) targets = ref_2q_clifford.cz_gate_counts_deterministic(shots) job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX') result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0)
class QasmResetTests: """QasmSimulator reset tests.""" SIMULATOR = QasmSimulator() BACKEND_OPTS = {} # --------------------------------------------------------------------- # Test reset # --------------------------------------------------------------------- def test_reset_deterministic(self): """Test QasmSimulator reset with for circuits with deterministic counts""" # For statevector output we can combine deterministic and non-deterministic # count output circuits shots = 100 circuits = ref_reset.reset_circuits_deterministic(final_measure=True) targets = ref_reset.reset_counts_deterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, backend_options=self.BACKEND_OPTS).result() self.assertTrue(getattr(result, 'success', False)) self.compare_counts(result, circuits, targets, delta=0) def test_reset_nondeterministic(self): """Test QasmSimulator reset with for circuits with non-deterministic counts""" # For statevector output we can combine deterministic and non-deterministic # count output circuits shots = 4000 circuits = ref_reset.reset_circuits_nondeterministic( final_measure=True) targets = ref_reset.reset_counts_nondeterministic(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, backend_options=self.BACKEND_OPTS).result() self.assertTrue(getattr(result, 'success', False)) self.compare_counts(result, circuits, targets, delta=0.05 * shots) def test_reset_sampling_opt(self): """Test sampling optimization""" shots = 4000 circuits = ref_reset.reset_circuits_sampling_optimization() targets = ref_reset.reset_counts_sampling_optimization(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, backend_options=self.BACKEND_OPTS).result() self.assertTrue(getattr(result, 'success', False)) self.compare_counts(result, circuits, targets, delta=0.05 * shots) def test_repeated_resets(self): """Test repeated reset operations""" shots = 100 circuits = ref_reset.reset_circuits_repeated() targets = ref_reset.reset_counts_repeated(shots) qobj = assemble(circuits, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run( qobj, backend_options=self.BACKEND_OPTS).result() self.assertTrue(getattr(result, 'success', False)) self.compare_counts(result, circuits, targets, delta=0)
def test_cx_gate_deterministic_default_basis_gates(self): """Test cx-gate circuits compiling to backend default basis_gates.""" shots = 100 circuits = ref_2q_clifford.cx_gate_circuits_deterministic(final_measure=True) targets = ref_2q_clifford.cx_gate_counts_deterministic(shots) job = execute(circuits, QasmSimulator(), shots=shots) result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0)
class QasmStandardGateDensityMatrixTests: """QasmSimulator standard gate library tests.""" SIMULATOR = QasmSimulator() BACKEND_OPTS = {} SEED = 9997 RNG = default_rng(seed=SEED) @data(*[(gate_params[0], gate_params[1], gate_params[2], basis_gates) for gate_params, basis_gates in product(GATES, BASIS_GATES)]) @unpack def test_gate_density_matrix(self, gate_cls, num_angles, has_ctrl_qubits, basis_gates): """Test standard gate simulation test.""" SUPPORTED_METHODS = [ 'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust', 'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust' ] backend_options = self.BACKEND_OPTS.copy() method = backend_options.pop('method', 'automatic') backend = self.SIMULATOR backend.set_options(method=method) circuits = self.gate_circuits(gate_cls, num_angles=num_angles, has_ctrl_qubits=has_ctrl_qubits, rng=self.RNG) for circuit in circuits: target = Statevector.from_instruction(circuit) # Add snapshot and execute circuit.snapshot_density_matrix('final') result = execute(circuit, backend, shots=1, basis_gates=basis_gates, optimization_level=0, **backend_options).result() # Check results success = getattr(result, 'success', False) msg = '{}, method = {}'.format(gate_cls.__name__, method) if method not in SUPPORTED_METHODS: self.assertFalse(success) else: self.assertTrue(success, msg=msg) self.assertSuccess(result) snapshots = result.data(0).get("snapshots", {}).get("density_matrix", {}) value = snapshots.get('final', [{'value': None}])[0]['value'] fidelity = state_fidelity(target, value) self.assertGreater(fidelity, 0.99999, msg=msg)
class QasmSaveStateTests: """QasmSimulator SaveState instruction tests.""" SIMULATOR = QasmSimulator() BACKEND_OPTS = {} def test_save_state(self): """Test save_amplitudes instruction""" REFERENCE_SAVE = { 'automatic': SaveStabilizer, 'stabilizer': SaveStabilizer, 'statevector': SaveStatevector, 'statevector_gpu': SaveStatevector, 'statevector_thrust': SaveStatevector, 'density_matrix': SaveDensityMatrix, 'density_matrix_gpu': SaveDensityMatrix, 'density_matrix_thrust': SaveDensityMatrix } REFERENCE_LABEL = { 'automatic': 'stabilizer', 'stabilizer': 'stabilizer', 'statevector': 'statevector', 'statevector_gpu': 'statevector', 'statevector_thrust': 'statevector', 'density_matrix': 'density_matrix', 'density_matrix_gpu': 'density_matrix', 'density_matrix_thrust': 'density_matrix' } opts = self.BACKEND_OPTS.copy() method = opts.get('method', 'automatic') if method in REFERENCE_SAVE: # Stabilizer test circuit num_qubits = 4 target_instr = REFERENCE_SAVE[method](num_qubits, label='target') circ = QuantumCircuit(num_qubits) circ.h(0) for i in range(1, num_qubits): circ.cx(i - 1, i) circ.save_state() circ.append(target_instr, range(num_qubits)) label = REFERENCE_LABEL[method] # Run qobj = assemble(circ, self.SIMULATOR) result = self.SIMULATOR.run(qobj, **opts).result() self.assertTrue(result.success) data = result.data(0) self.assertIn(label, data) self.assertIn('target', data) value = data[label] target = data['target'] self.assertTrue(np.all(value == target))
class QasmPauliNoiseTests: """QasmSimulator pauli error noise model tests.""" SIMULATOR = QasmSimulator() BACKEND_OPTS = {} def test_pauli_gate_noise(self): """Test simulation with Pauli gate error noise model.""" shots = 1000 circuits = ref_pauli_noise.pauli_gate_error_circuits() noise_models = ref_pauli_noise.pauli_gate_error_noise_models() targets = ref_pauli_noise.pauli_gate_error_counts(shots) for circuit, noise_model, target in zip(circuits, noise_models, targets): qobj = assemble(circuit, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run(qobj, noise_model=noise_model, **self.BACKEND_OPTS).result() self.assertSuccess(result) self.compare_counts(result, [circuit], [target], delta=0.05 * shots) def test_pauli_reset_noise(self): """Test simulation with Pauli reset error noise model.""" shots = 1000 circuits = ref_pauli_noise.pauli_reset_error_circuits() noise_models = ref_pauli_noise.pauli_reset_error_noise_models() targets = ref_pauli_noise.pauli_reset_error_counts(shots) for circuit, noise_model, target in zip(circuits, noise_models, targets): qobj = assemble(circuit, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run(qobj, noise_model=noise_model, **self.BACKEND_OPTS).result() self.assertSuccess(result) self.compare_counts(result, [circuit], [target], delta=0.05 * shots) def test_pauli_measure_noise(self): """Test simulation with Pauli measure error noise model.""" shots = 1000 circuits = ref_pauli_noise.pauli_measure_error_circuits() noise_models = ref_pauli_noise.pauli_measure_error_noise_models() targets = ref_pauli_noise.pauli_measure_error_counts(shots) for circuit, noise_model, target in zip(circuits, noise_models, targets): qobj = assemble(circuit, self.SIMULATOR, shots=shots) result = self.SIMULATOR.run(qobj, noise_model=noise_model, **self.BACKEND_OPTS).result() self.assertSuccess(result) self.compare_counts(result, [circuit], [target], delta=0.05 * shots)
class QuantumVolumeTimeSuite: """ Benchmarking times for Quantum Volume with various noise configurations - ideal (no noise) - mixed state - reset - kraus For each noise model, we want to test various configurations of number of qubits The methods defined in this class will be executed by ASV framework as many times as the combination of all parameters exist in `self.params`, for exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times: time_method(1,4) time_method(1,5) time_method(1,6) time_method(2,4) time_method(2,5) time_method(2,6) time_method(3,4) time_method(3,5) time_method(3,6) """ def __init__(self): self.timeout = 60 * 20 self.qv_circuits = [] self.backend = QasmSimulator() for num_qubits in (16, ): for depth in (10, ): # We want always the same seed, as we want always the same circuits # for the same value pairs of qubits,depth circ = quantum_volume_circuit(num_qubits, depth, seed=1) self.qv_circuits.append( Terra.compile(circ, self.backend, shots=1, basis_gates=['u3', 'cx'])) self.param_names = ["Quantum Volume (16qubits 10depth)", "Noise Model"] # This will run every benchmark for one of the combinations we have here: # bench(qv_circuits, None) => bench(qv_circuits, mixed()) => # bench(qv_circuits, reset) => bench(qv_circuits, kraus()) self.params = (self.qv_circuits, [ None, mixed_unitary_noise_model(), reset_noise_model(), kraus_noise_model() ]) def setup(self, qobj): pass def time_quantum_volume(self, qobj, noise_model): result = self.backend.run(qobj, noise_model=noise_model).result() if result.status != 'COMPLETED': raise QiskitError("Simulation failed. Status: " + result.status)
def set_qasm(sim_opts): sim_method = [opt for opt in sim_opts if opt.startswith('method')] if len(sim_method) == 0: backend = QasmSimulator(method='automatic', max_memory_mb=2048) sim_method = 'automatic' else: sim_method = sim_method[0].split('=')[1].strip('\n') if sim_method not in qasm_methods: print('SimulationError: simulation method not available. Available options: "statevector", "density_matrix", "matrix_product_state", "automatic"') sys.exit() else: backend = QasmSimulator(method=sim_method, max_memory_mb=2048) return backend, sim_method
def __init__(self,ising,p,qubits,useNoiseModel = False): self.ising = ising self.p = p self.useNoiseModel = useNoiseModel self.qubits = qubits self.register = None self.q = QuantumRegister(qubits) self.c = ClassicalRegister(qubits) self.register = QuantumCircuit(self.q, self.c) self.backend = QasmSimulator()
def test_grovers_minimal_basis_gates(self): """Test grovers circuits compiling to U,CX""" shots = 2000 circuits = ref_algorithms.grovers_circuit(final_measure=True, allow_sampling=True) targets = ref_algorithms.grovers_counts(shots) job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX') result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_reset_nondeterministic(self): """Test QasmSimulator reset with for circuits with non-deterministic counts""" # For statevector output we can combine deterministic and non-deterministic # count output circuits shots = 2000 circuits = ref_reset.reset_circuits_nondeterministic(final_measure=True) targets = ref_reset.reset_counts_nondeterministic(shots) job = execute(circuits, QasmSimulator(), shots=shots) result = job.result() self.is_completed(result) self.compare_counts(result, circuits, targets, delta=0.05 * shots)
class QuantumFourierTransformFusionSuite: def __init__(self): self.timeout = 60 * 20 self.backend = QasmSimulator() num_qubits = [5, 10, 15, 20, 25] self.circuit = {} for num_qubit in num_qubits: for use_cu1 in [True, False]: circuit = self.qft_circuit(num_qubit, use_cu1) self.circuit[(num_qubit, use_cu1)] = assemble(circuit, self.backend, shots=1) self.param_names = [ "Quantum Fourier Transform", "Fusion Activated", "Use cu1 gate" ] self.params = (num_qubits, [True, False], [True, False]) @staticmethod def qft_circuit(num_qubit, use_cu1): qreg = QuantumRegister(num_qubit, "q") creg = ClassicalRegister(num_qubit, "c") circuit = QuantumCircuit(qreg, creg) for i in range(num_qubit): circuit.h(qreg[i]) for i in range(num_qubit): for j in range(i): l = math.pi / float(2**(i - j)) if use_cu1: circuit.cu1(l, qreg[i], qreg[j]) else: circuit.u1(l / 2, qreg[i]) circuit.cx(qreg[i], qreg[j]) circuit.u1(-l / 2, qreg[j]) circuit.cx(qreg[i], qreg[j]) circuit.u1(l / 2, qreg[j]) circuit.h(qreg[i]) circuit.barrier() for i in range(num_qubit): circuit.measure(qreg[i], creg[i]) return circuit def time_quantum_fourier_transform(self, num_qubit, fusion_enable, use_cu1): """ Benchmark QFT """ result = self.backend.run(self.circuit[(num_qubit, use_cu1)], backend_options={ 'fusion_enable': fusion_enable }).result() if result.status != 'COMPLETED': raise QiskitError("Simulation failed. Status: " + result.status)
def SimW(cir): simulator_qasm = BasicAer.get_backend('qasm_simulator') noise_simulator = QasmSimulator.from_backend(device_backend) if intro_noise == 0: simulator = simulator_qasm else: simulator = noise_simulator result = execute(cir, simulator, shots=num_shot).result() counts = result.get_counts(cir) #plot_histogram(counts, title='Bell-State counts') return counts
def __init__(self): self.timeout = 60 * 20 self.qft_circuits = [] self.backend = QasmSimulator() for num_qubits in (5, 10, 15): circ = quantum_fourier_transform_circuit(num_qubits) circ = transpile(circ) qobj = assemble(circ, self.backend, shots=1) self.qft_circuits.append(qobj) self.param_names = ["Quantum Fourier Transform", "Noise Model"] # This will run every benchmark for one of the combinations we have here: # bench(qft_circuits, None) => bench(qft_circuits, mixed()) => # bench(qft_circuits, reset) => bench(qft_circuits, kraus()) self.params = (self.qft_circuits, [ no_noise(), mixed_unitary_noise_model(), reset_noise_model(), kraus_noise_model() ])
class TestQasmSimulatorDensityMatrixThrustGPU(common.QiskitAerTestCase, DensityMatrixTests): """QasmSimulator density_matrix_gpu method tests.""" BACKEND_OPTS = { "seed_simulator": 314159, "method": "density_matrix_gpu", "max_parallel_threads": 1 } try: SIMULATOR = QasmSimulator(**BACKEND_OPTS) except AerError: SIMULATOR = None
class QuantumFourierTransformTimeSuite: """ Benchmarking times for Quantum Fourier Transform with various noise configurations - ideal (no noise) - mixed state - reset - kraus For each noise model, we want to test various configurations of number of qubits The methods defined in this class will be executed by ASV framework as many times as the combination of all parameters exist in `self.params`, for exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times: time_method(1,4) time_method(1,5) time_method(1,6) time_method(2,4) time_method(2,5) time_method(2,6) time_method(3,4) time_method(3,5) time_method(3,6) """ def __init__(self): self.timeout = 60 * 20 self.qft_circuits = [] self.backend = QasmSimulator() for num_qubits in (5, 10, 15): circ = quantum_fourier_transform_circuit(num_qubits) circ = transpile(circ) qobj = assemble(circ, self.backend, shots=1) self.qft_circuits.append(qobj) self.param_names = ["Quantum Fourier Transform", "Noise Model"] # This will run every benchmark for one of the combinations we have here: # bench(qft_circuits, None) => bench(qft_circuits, mixed()) => # bench(qft_circuits, reset) => bench(qft_circuits, kraus()) self.params = (self.qft_circuits, [ no_noise(), mixed_unitary_noise_model(), reset_noise_model(), kraus_noise_model() ]) def setup(self, qobj, noise_model_wrapper): pass def time_quantum_fourier_transform(self, qobj, noise_model_wrapper): result = self.backend.run(qobj, noise_model=noise_model_wrapper()).result() if result.status != 'COMPLETED': raise QiskitError("Simulation failed. Status: " + result.status)
class RandomFusionSuite: def __init__(self): self.timeout = 60 * 20 self.backend = QasmSimulator() self.param_names = ["Number of Qubits", "Fusion Activated"] self.params = ([5, 10, 15, 20, 25], [True, False]) @staticmethod def build_model_circuit_kak(width, depth, seed=None): """Create quantum volume model circuit on quantum register qreg of given depth (default depth is equal to width) and random seed. The model circuits consist of layers of Haar random elements of U(4) applied between corresponding pairs of qubits in a random bipartition. """ qreg = QuantumRegister(width) depth = depth or width np.random.seed(seed) circuit = QuantumCircuit(qreg, name="Qvolume: %s by %s, seed: %s" % (width, depth, seed)) for _ in range(depth): # Generate uniformly random permutation Pj of [0...n-1] perm = np.random.permutation(width) # For each pair p in Pj, generate Haar random U(4) # Decompose each U(4) into CNOT + SU(2) for k in range(width // 2): U = random_unitary(4, seed).data for gate in two_qubit_cnot_decompose(U): qs = [qreg[int(perm[2 * k + i.index])] for i in gate[1]] pars = gate[0].params name = gate[0].name if name == "cx": circuit.cx(qs[0], qs[1]) elif name == "u1": circuit.u1(pars[0], qs[0]) elif name == "u2": circuit.u2(*pars[:2], qs[0]) elif name == "u3": circuit.u3(*pars[:3], qs[0]) elif name == "id": pass # do nothing else: raise Exception("Unexpected gate name: %s" % name) return circuit def time_random_transform(self, num_qubits, fusion_enable): circ = self.build_model_circuit_kak(num_qubits, num_qubits, 1) qobj = assemble(circ) result = self.backend.run(qobj, fusion_enable=fusion_enable).result() if result.status != 'COMPLETED': raise QiskitError("Simulation failed. Status: " + result.status)
def calculateEnergy(self, transpiledCircuit): if self.useNoiseModel == True: p_reset = 0.003 p_meas = 0.01 p_gate1 = 0.05 # QuantumError objects error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)]) error_meas = pauli_error([('X', p_meas), ('I', 1 - p_meas)]) error_gate1 = pauli_error([('X', p_gate1), ('I', 1 - p_gate1)]) error_gate2 = error_gate1.tensor(error_gate1) noise_bit_flip = NoiseModel() noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset") noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure") noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"]) noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"]) simulator = QasmSimulator() job = execute(transpiledCircuit, backend=simulator, basis_gates=noise_bit_flip.basis_gates, noise_model=noise_bit_flip) results = job.result() counts = results.get_counts() _paulis, sgift = get_pauliList(self.ising, self.qubits) _basis = [(pauli[1], [i]) for i, pauli in enumerate(_paulis)] num_shots = sum(list(results.get_counts().values())) results = parallel_map(WeightedPauliOperator._routine_compute_mean_and_var, [([_paulis[idx] for idx in indices], results.get_counts()) for basis, indices in _basis], num_processes=aqua_globals.num_processes) return results[0][0] else: _paulis, sgift = get_pauliList(self.ising, self.qubits) _basis = [(pauli[1], [i]) for i, pauli in enumerate(_paulis)] job = execute(transpiledCircuit, backend=self.backend) results = job.result() counts = results.get_counts() num_shots = sum(list(results.get_counts().values())) results = parallel_map(WeightedPauliOperator._routine_compute_mean_and_var, [([_paulis[idx] for idx in indices], results.get_counts()) for basis, indices in _basis], num_processes=aqua_globals.num_processes) return results[0][0]
class TestQasmSimulatorStatevectorMPI(common.QiskitAerTestCase, StatevectorMPITests): """QasmSimulator statevector method MPI tests.""" BACKEND_OPTS = { "seed_simulator": 271828, "method": "statevector", "blocking_enable": True, "blocking_qubits": 6, "max_parallel_threads": 1 } SIMULATOR = QasmSimulator(**BACKEND_OPTS)
def circuit2(): print("\nCircuit 2") # Use Aer's qasm_simulator simulator = QasmSimulator() # Create a Quantum Circuit acting on the q register circuit = QuantumCircuit(3, 3, name="Circuit2") # Add a H gate on qubit 0 circuit.h(0) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1 circuit.cx(0, 1) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1 circuit.cx(0, 2) # Map the quantum measurement to the classical bits circuit.measure([0,1,2], [0,1,2]) # # compile the circuit down to low-level QASM instructions # supported by the backend (not needed for simple circuits) compiled_circuit = transpile(circuit, simulator) # Execute the circuit on the qasm simulator job = simulator.run(compiled_circuit, shots=100) # Grab results from the job result = job.result() # Draw the circuit #circuit.draw() print(circuit) circuit.draw(output='mpl', filename='E:\_Ricks\Python\Qiskit1\circuit2.png') # Returns counts counts = result.get_counts(circuit) print("\nTotal counts are:",counts)
class SimpleU3TimeSuite: """ Benchmark simple circuits with just one U3 gate The methods defined in this class will be executed by ASV framework as many times as the combination of all parameters exist in `self.params`, for exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times: time_method(1,4) time_method(1,5) time_method(1,6) time_method(2,4) time_method(2,5) time_method(2,6) time_method(3,4) time_method(3,5) time_method(3,6) For each noise model, we want to test various configurations of number of qubits """ def __init__(self): self.timeout = 60 * 20 self.backend = QasmSimulator() self.circuits = [] for i in 5, 10, 15: circuit = simple_u3_circuit(i) self.circuits.append( Terra.compile(circuit, self.backend, shots=1) ) self.param_names = [ "Simple u3 circuits (5/16/20/30 qubits)", "Noise model" ] self.params = ( self.circuits, [ None, mixed_unitary_noise_model(), reset_noise_model(), kraus_noise_model() ] ) def time_simple_u3(self, qobj, noise_model): result = self.backend.run( qobj, noise_model=noise_model ).result() if result.status != 'COMPLETED': raise QiskitError("Simulation failed. Status: " + result.status)
def __init__(self): self.timeout = 60 * 20 self.qv_circuits = [] self.backend = QasmSimulator() for num_qubits in (5, 10, 15): for depth in (10, ): # We want always the same seed, as we want always the same circuits # for the same value pairs of qubits,depth circ = quantum_volume_circuit(num_qubits, depth, seed=1) circ = transpile(circ, basis_gates=['u3', 'cx']) qobj = assemble(circ, self.backend, shots=1) self.qv_circuits.append(qobj) self.param_names = ["Quantum Volume", "Noise Model"] # This will run every benchmark for one of the combinations we have here: # bench(qv_circuits, None) => bench(qv_circuits, mixed()) => # bench(qv_circuits, reset) => bench(qv_circuits, kraus()) self.params = (self.qv_circuits, [ no_noise(), mixed_unitary_noise_model(), reset_noise_model(), kraus_noise_model() ])
def __init__(self): self.timeout = 60 * 20 self.backend = QasmSimulator() self.circuits = [] self.param_names = [ "Simple cnot circuits (5/16/20/30 qubits)", "Noise model" ] for i in 5, 10, 15: circuit = simple_cnot_circuit(i) self.circuits.append( Terra.compile(circuit, self.backend, shots=1) ) self.params = ( self.circuits, [ None, mixed_unitary_noise_model(), reset_noise_model(), kraus_noise_model() ] )
class TestQasmSimulatorStatevectorThrustGPU(common.QiskitAerTestCase, StatevectorTests): """QasmSimulator statevector_gpu method tests.""" BACKEND_OPTS = { "seed_simulator": 271828, "method": "statevector_gpu", "max_parallel_threads": 1 } try: SIMULATOR = QasmSimulator(**BACKEND_OPTS) except AerError: SIMULATOR = None
def test_quantum_instance_with_backend_shots(self): """Test sampling a circuit where the backend has shots attached.""" try: from qiskit.providers.aer import QasmSimulator except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) backend = QasmSimulator(shots=10) sampler = CircuitSampler(backend) res = sampler.convert(~Plus @ Plus).eval() self.assertAlmostEqual(res, 1 + 0j, places=2)