def test_run(forest): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer(name='testy!', qam=QVM(connection=forest, gate_noise=[0.01] * 3), device=device, compiler=DummyCompiler()) bitstrings = qc.run(Program(H(0), CNOT(0, 1), CNOT(1, 2), MEASURE(0, 0), MEASURE(1, 1), MEASURE(2, 2)).wrap_in_numshots_loop(1000), classical_addresses=None) assert bitstrings.shape == (1000, 3) parity = np.sum(bitstrings, axis=1) % 3 assert 0 < np.mean(parity) < 0.15
def test_run_with_parameters(forest): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer(name='testy!', qam=QVM(connection=forest), device=device, compiler=DummyCompiler()) bitstrings = qc.run(executable=Program( Declare(name='theta', memory_type='REAL'), Declare(name='ro', memory_type='BIT'), RX(MemoryReference('theta'), 0), MEASURE(0, MemoryReference('ro'))).wrap_in_numshots_loop(1000), memory_map={'theta': [np.pi]}) assert bitstrings.shape == (1000, 1) assert all([bit == 1 for bit in bitstrings])
def test_readout_symmetrization(forest): device = NxDevice(nx.complete_graph(3)) noise_model = decoherence_noise_with_asymmetric_ro( gates=gates_in_isa(device.get_isa())) qc = QuantumComputer(name='testy!', qam=QVM(connection=forest, noise_model=noise_model), device=device, compiler=DummyCompiler()) prog = Program(I(0), X(1), MEASURE(0, 0), MEASURE(1, 1)) prog.wrap_in_numshots_loop(1000) bs1 = qc.run(prog) avg0_us = np.mean(bs1[:, 0]) avg1_us = 1 - np.mean(bs1[:, 1]) diff_us = avg1_us - avg0_us assert diff_us > 0.03 bs2 = qc.run_symmetrized_readout(prog, 1000) avg0_s = np.mean(bs2[:, 0]) avg1_s = 1 - np.mean(bs2[:, 1]) diff_s = avg1_s - avg0_s assert diff_s < 0.05
def test_run_pyqvm_noiseless(): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer( name="testy!", qam=PyQVM(n_qubits=3), device=device, compiler=DummyCompiler() ) prog = Program(H(0), CNOT(0, 1), CNOT(1, 2)) ro = prog.declare("ro", "BIT", 3) for q in range(3): prog += MEASURE(q, ro[q]) bitstrings = qc.run(prog.wrap_in_numshots_loop(1000)) assert bitstrings.shape == (1000, 3) parity = np.sum(bitstrings, axis=1) % 3 assert np.mean(parity) == 0
def test_run_pyqvm_noisy(): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer( name='testy!', qam=PyQVM(n_qubits=3, post_gate_noise_probabilities={'relaxation': 0.01}), device=device, compiler=DummyCompiler()) bitstrings = qc.run( Program(H(0), CNOT(0, 1), CNOT(1, 2), MEASURE(0, 0), MEASURE(1, 1), MEASURE(2, 2)).wrap_in_numshots_loop(1000)) assert bitstrings.shape == (1000, 3) parity = np.sum(bitstrings, axis=1) % 3 assert 0 < np.mean(parity) < 0.15
def __init__(self, data, label, shuffle=False, qpu=False): weights = np.load(data) n_graphs = len(weights) # read labels from file, or as single label if os.path.exists(label): labels = np.load(label) else: labels = [label for _ in range(n_graphs)] if shuffle: self._shuffled_order = np.random.permutation(n_graphs) weights = weights[self._shuffled_order] labels = labels[self._shuffled_order] self.pset = AllProblems(weights, labels) self.num_qubits = self.pset.num_variables() qubits = list(range(self.num_qubits)) angles = np.linspace(0, 2 * np.pi, NUM_ANGLES, endpoint=False) self.instrs = [ CNOT(q0, q1) for q0, q1 in product(qubits, qubits) if q0 != q1 ] self.instrs += [ op(theta, q) for q, op, theta in product(qubits, [RX, RY, RZ], angles) ] self.action_space = gym.spaces.Discrete(len(self.instrs)) obs_len = NUM_SHOTS * self.num_qubits + len(self.pset.problem(0)) self.observation_space = gym.spaces.Box(np.full(obs_len, -1.0), np.full(obs_len, 1.0), dtype=np.float32) self.reward_threshold = 0.8 self.qpu = qpu if qpu: self._qc = get_qc(QPU_NAME) else: self._qc = QuantumComputer( name="qvm", qam=PyQVM(n_qubits=self.num_qubits), device=NxDevice(nx.complete_graph(self.num_qubits)), compiler=MinimalPyQVMCompiler(), ) self.reset()
def test_run_with_parameters(forest): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer( name="testy!", qam=QVM(connection=forest), device=device, compiler=DummyCompiler() ) bitstrings = qc.run( executable=Program( Declare(name="theta", memory_type="REAL"), Declare(name="ro", memory_type="BIT"), RX(MemoryReference("theta"), 0), MEASURE(0, MemoryReference("ro")), ).wrap_in_numshots_loop(1000), memory_map={"theta": [np.pi]}, ) assert bitstrings.shape == (1000, 1) assert all([bit == 1 for bit in bitstrings])
def get_test_qc(n_qubits): class BasicQVMCompiler(AbstractCompiler): def quil_to_native_quil(self, program: Program): return basic_compile(program) def native_quil_to_executable(self, nq_program: Program): return PyQuilExecutableResponse( program=nq_program.out(), attributes=_extract_attribute_dictionary_from_program( nq_program)) return QuantumComputer( name='testing-qc', qam=PyQVM(n_qubits=n_qubits, seed=52), device=NxDevice(nx.complete_graph(n_qubits)), compiler=BasicQVMCompiler(), )
def test_for_negative_probabilities(): # trivial program to do state tomography on prog = Program(I(0)) # make TomographyExperiment expt_settings = [ExperimentSetting(zeros_state([0]), pt) for pt in [sI(0), sX(0), sY(0), sZ(0)]] experiment_1q = TomographyExperiment(settings=expt_settings, program=prog) # make an abstract compiler class DummyCompiler(AbstractCompiler): def get_version_info(self): return {} def quil_to_native_quil(self, program: Program): return program def native_quil_to_executable(self, nq_program: Program): return nq_program # make a quantum computer object device = NxDevice(nx.complete_graph(1)) qc_density = QuantumComputer(name='testy!', qam=PyQVM(n_qubits=1, quantum_simulator_type=ReferenceDensitySimulator), device=device, compiler=DummyCompiler()) # initialize with a pure state initial_density = np.array([[1.0, 0.0], [0.0, 0.0]]) qc_density.qam.wf_simulator.density = initial_density try: list(measure_observables(qc=qc_density, tomo_experiment=experiment_1q, n_shots=3000)) except ValueError as e: # the error is from np.random.choice by way of self.rs.choice in ReferenceDensitySimulator assert str(e) != 'probabilities are not non-negative' # initialize with a mixed state initial_density = np.array([[0.9, 0.0], [0.0, 0.1]]) qc_density.qam.wf_simulator.density = initial_density try: list(measure_observables(qc=qc_density, tomo_experiment=experiment_1q, n_shots=3000)) except ValueError as e: assert str(e) != 'probabilities are not non-negative'
def test_for_negative_probabilities(): # trivial program to do state tomography on prog = Program(I(0)) # make an Experiment expt_settings = [ ExperimentSetting(zeros_state([0]), pt) for pt in [sI(0), sX(0), sY(0), sZ(0)] ] experiment_1q = Experiment(settings=expt_settings, program=prog) # make a quantum computer object device = NxDevice(nx.complete_graph(1)) qc_density = QuantumComputer( name="testy!", qam=PyQVM(n_qubits=1, quantum_simulator_type=ReferenceDensitySimulator), device=device, compiler=DummyCompiler(), ) # initialize with a pure state initial_density = np.array([[1.0, 0.0], [0.0, 0.0]]) qc_density.qam.wf_simulator.density = initial_density try: list( measure_observables(qc=qc_density, tomo_experiment=experiment_1q, n_shots=3000)) except ValueError as e: # the error is from np.random.choice by way of self.rs.choice in ReferenceDensitySimulator assert str(e) != "probabilities are not non-negative" # initialize with a mixed state initial_density = np.array([[0.9, 0.0], [0.0, 0.1]]) qc_density.qam.wf_simulator.density = initial_density try: list( measure_observables(qc=qc_density, tomo_experiment=experiment_1q, n_shots=3000)) except ValueError as e: assert str(e) != "probabilities are not non-negative"
def quil_compile(input, device): name = device["name"] g = nx.Graph() g.add_edges_from(device["topology"]) qc = NxDevice(g) p = Program(open(f"input/{input}.quil", "r").read()) compiler = LocalQVMCompiler("http://localhost:6000", qc) np = compiler.quil_to_native_quil(p) volume, depth = np.native_quil_metadata[ "gate_volume"], np.native_quil_metadata["gate_depth"] with open(f"output/{input}_{name}.quil", "w") as f: f.write(str(np)) with open(f"output/{input}_{name}.json", "w") as f: f.write(json.dumps({'volume': volume, 'depth': depth}))
def test_qc_expectation_larger_lattice(forest): device = NxDevice(nx.complete_graph(4)) qc = QuantumComputer(name='testy!', qam=QVM(connection=forest), device=device, compiler=DummyCompiler()) q0 = 2 q1 = 3 # bell state program p = Program() p += RESET() p += H(q0) p += CNOT(q0, q1) p.wrap_in_numshots_loop(10) # XX, YY, ZZ experiment sx = ExperimentSetting(in_state=sZ(q0) * sZ(q1), out_operator=sX(q0) * sX(q1)) sy = ExperimentSetting(in_state=sZ(q0) * sZ(q1), out_operator=sY(q0) * sY(q1)) sz = ExperimentSetting(in_state=sZ(q0) * sZ(q1), out_operator=sZ(q0) * sZ(q1)) e = TomographyExperiment(settings=[sx, sy, sz], program=p) results = qc.experiment(e) # XX expectation value for bell state |00> + |11> is 1 assert np.isclose(results[0].expectation, 1) assert np.isclose(results[0].std_err, 0) assert results[0].total_counts == 40 # YY expectation value for bell state |00> + |11> is -1 assert np.isclose(results[1].expectation, -1) assert np.isclose(results[1].std_err, 0) assert results[1].total_counts == 40 # ZZ expectation value for bell state |00> + |11> is 1 assert np.isclose(results[2].expectation, 1) assert np.isclose(results[2].std_err, 0) assert results[2].total_counts == 40
def test_run(forest): qc = QuantumComputer( name='testy!', qam=QVM(connection=forest, gate_noise=[0.01] * 3), device=NxDevice(nx.complete_graph(3)), ) bitstrings = qc.run(Program( H(0), CNOT(0, 1), CNOT(1, 2), MEASURE(0, 0), MEASURE(1, 1), MEASURE(2, 2), ), classical_addresses=[0, 1, 2], trials=1000) assert bitstrings.shape == (1000, 3) parity = np.sum(bitstrings, axis=1) % 3 assert 0 < np.mean(parity) < 0.15
def test_measure_bitstrings(forest): device = NxDevice(nx.complete_graph(2)) qc_pyqvm = QuantumComputer( name="testy!", qam=PyQVM(n_qubits=2), device=device, compiler=DummyCompiler() ) qc_forest = QuantumComputer( name="testy!", qam=QVM(connection=forest, gate_noise=[0.00] * 3), device=device, compiler=DummyCompiler(), ) prog = Program(I(0), I(1)) meas_qubits = [0, 1] sym_progs, flip_array = _symmetrization(prog, meas_qubits, symm_type=-1) results = _measure_bitstrings(qc_pyqvm, sym_progs, meas_qubits, num_shots=1) # test with pyQVM answer = [np.array([[0, 0]]), np.array([[0, 1]]), np.array([[1, 0]]), np.array([[1, 1]])] assert all([np.allclose(x, y) for x, y in zip(results, answer)]) # test with regular QVM results = _measure_bitstrings(qc_forest, sym_progs, meas_qubits, num_shots=1) assert all([np.allclose(x, y) for x, y in zip(results, answer)])
def get_test_qc(n_qubits): class BasicQVMCompiler(AbstractCompiler): def quil_to_native_quil(self, program: Program): return basic_compile(program) def native_quil_to_executable(self, nq_program: Program): return PyQuilExecutableResponse( program=nq_program.out(), attributes=_extract_attribute_dictionary_from_program(nq_program)) try: qc = QuantumComputer( name='testing-qc', qam=QVM(connection=ForestConnection(), random_seed=52), device=NxDevice(nx.complete_graph(n_qubits)), compiler=BasicQVMCompiler(), ) qc.run_and_measure(Program(I(0)), trials=1) return qc except (RequestException, TimeoutError) as e: return pytest.skip("This test requires a running local QVM: {}".format(e))
def test_qpu_run(): config = PyquilConfig() if config.qpu_url and config.qpu_compiler_url: g = nx.Graph() g.add_node(0) device = NxDevice(g) qc = QuantumComputer( name="pyQuil test QC", qam=QPU(endpoint=config.qpu_url, user="******"), device=device, compiler=QPUCompiler(endpoint=config.compiler_url, device=device), ) bitstrings = qc.run_and_measure(program=Program(X(0)), trials=1000) assert bitstrings[0].shape == (1000, ) assert np.mean(bitstrings[0]) > 0.8 bitstrings = qc.run(qc.compile(Program(X(0)))) assert bitstrings.shape == (0, 0) else: pytest.skip( "QPU or compiler-server not available; skipping QPU run test.")
def test_run_pyqvm_noiseless(): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer( name='testy!', qam=PyQVM(n_qubits=3), device=device, compiler=DummyCompiler() ) bitstrings = qc.run( Program( H(0), CNOT(0, 1), CNOT(1, 2), MEASURE(0, 0), MEASURE(1, 1), MEASURE(2, 2)).wrap_in_numshots_loop(1000) ) assert bitstrings.shape == (1000, 3) parity = np.sum(bitstrings, axis=1) % 3 assert np.mean(parity) == 0
def test_qc_expectation_on_qvm_that_requires_executable(forest): # regression test for https://github.com/rigetti/forest-tutorials/issues/2 device = NxDevice(nx.complete_graph(2)) qc = QuantumComputer( name="testy!", qam=QVM(connection=forest, requires_executable=True), device=device, compiler=DummyCompiler(), ) p = Program() theta = p.declare("theta", "REAL") p += RESET() p += RY(theta, 0) p.wrap_in_numshots_loop(10000) sx = ExperimentSetting(in_state=sZ(0), out_operator=sX(0)) e = Experiment(settings=[sx], program=p) thetas = [-np.pi / 2, 0.0, np.pi / 2] results = [] # Verify that multiple calls to qc.experiment with the same experiment backed by a QVM that # requires_exectutable does not raise an exception. for theta in thetas: results.append(qc.experiment(e, memory_map={"theta": [theta]})) assert np.isclose(results[0][0].expectation, -1.0, atol=0.01) assert np.isclose(results[0][0].std_err, 0) assert results[0][0].total_counts == 20000 # bounds on atol and std_err here are a little loose to try and avoid test flakiness. assert np.isclose(results[1][0].expectation, 0.0, atol=0.1) assert results[1][0].std_err < 0.01 assert results[1][0].total_counts == 20000 assert np.isclose(results[2][0].expectation, 1.0, atol=0.01) assert np.isclose(results[2][0].std_err, 0) assert results[2][0].total_counts == 20000
def test_run(forest): device = NxDevice(nx.complete_graph(3)) qc = QuantumComputer( name="testy!", qam=QVM(connection=forest, gate_noise=[0.01] * 3), device=device, compiler=DummyCompiler(), ) bitstrings = qc.run( Program( Declare("ro", "BIT", 3), H(0), CNOT(0, 1), CNOT(1, 2), MEASURE(0, MemoryReference("ro", 0)), MEASURE(1, MemoryReference("ro", 1)), MEASURE(2, MemoryReference("ro", 2)), ).wrap_in_numshots_loop(1000)) assert bitstrings.shape == (1000, 3) parity = np.sum(bitstrings, axis=1) % 3 assert 0 < np.mean(parity) < 0.15
def test_set_initial_state(): # That is test the assigned state matrix in ReferenceDensitySimulator is persistent between # rounds of run. rho1 = np.array([[0.0, 0.0], [0.0, 1.0]]) # run prog prog = Program(I(0)) ro = prog.declare("ro", "BIT", 1) prog += MEASURE(0, ro[0]) # make a quantum computer object device = NxDevice(nx.complete_graph(1)) qc_density = QuantumComputer( name="testy!", qam=PyQVM(n_qubits=1, quantum_simulator_type=ReferenceDensitySimulator), device=device, compiler=DummyCompiler(), ) qc_density.qam.wf_simulator.set_initial_state(rho1).reset() out = [qc_density.run(prog) for _ in range(0, 4)] ans = [np.array([[1]]), np.array([[1]]), np.array([[1]]), np.array([[1]])] assert all([np.allclose(x, y) for x, y in zip(out, ans)]) # Run and measure style progRAM = Program(I(0)) results = qc_density.run_and_measure(progRAM, trials=10) ans = {0: np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])} assert np.allclose(results[0], ans[0]) # test reverting ReferenceDensitySimulator to the default state rho0 = np.array([[1.0, 0.0], [0.0, 0.0]]) qc_density.qam.wf_simulator.set_initial_state(rho0).reset() assert np.allclose(qc_density.qam.wf_simulator.density, rho0) assert np.allclose(qc_density.qam.wf_simulator.initial_density, rho0)
from pyquil.api._quantum_computer import _get_qvm_with_topology from pyquil.device import NxDevice, gates_in_isa from pyquil import Program, get_qc from pyquil.gates import * def make_circuit()-> Program: prog = Program() prog += X(1) prog += X(2) prog += CCNOT(1,2,0) # number=8 # circuit end return prog if __name__ == '__main__': #qubits = [0, 1, 2, 3, 4, 5, 6] # qubits are numbered by octagon edges = [(0, 1), (1, 0), (2, 3), (3, 2)] # second octagon topo = nx.from_edgelist(edges) device = NxDevice(topology=topo) qc = _get_qvm_with_topology(name="line",topology=topo) print(qc.run_and_measure(make_circuit(),10)) #pyquil seems should use this way to do the topology
def __init__(self, clauses, m=None, steps=1, grid_size=None, tol=1e-5, gate_noise=None, verbose=False, visualize=False): self.clauses = clauses self.m = m self.verbose = verbose self.visualize = visualize self.step_by_step_results = None self.optimization_history = None self.gate_noise = gate_noise if grid_size is None: self.grid_size = len(clauses) + len(qubits) else: self.grid_size = grid_size cost_operators, mapping = self.create_operators_from_clauses() self.mapping = mapping driver_operators = self.create_driver_operators() # minimizer_kwargs = {'method': 'BFGS', # 'options': {'gtol': tol, 'disp': False}} # bounds = [(0, np.pi)]*steps + [(0, 2*np.pi)]*steps # minimizer_kwargs = {'method': 'L-BFGS-B', # 'options': {'gtol': tol, 'disp': False}, # 'bounds': bounds} minimizer_kwargs = { 'method': 'Nelder-Mead', 'options': { 'ftol': tol, 'tol': tol, 'disp': False } } if self.verbose: print_fun = print else: print_fun = pass_fun qubits = list(range(len(mapping))) if gate_noise: self.samples = int(1e3) pauli_channel = [gate_noise] * 3 else: self.samples = None pauli_channel = None connection = ForestConnection() qvm = QVM(connection=connection, gate_noise=pauli_channel) topology = nx.complete_graph(len(qubits)) device = NxDevice(topology=topology) qc = QuantumComputer(name="my_qvm", qam=qvm, device=device, compiler=QVMCompiler( device=device, endpoint=connection.compiler_endpoint)) vqe_option = { 'disp': print_fun, 'return_all': True, 'samples': self.samples } self.qaoa_inst = QAOA(qc, qubits, steps=steps, init_betas=None, init_gammas=None, cost_ham=cost_operators, ref_ham=driver_operators, minimizer=scipy.optimize.minimize, minimizer_kwargs=minimizer_kwargs, rand_seed=None, vqe_options=vqe_option, store_basis=True) self.ax = None
import networkx as nx from pyquil import Program from pyquil.gates import X from pyquil.device import NxDevice from pyquil.api._qac import AbstractCompiler from pyquil.api import QuantumComputer, QVM, ForestConnection from matplotlib import pyplot as plt topology = nx.from_edgelist([ (10, 2), (10, 4), (10, 6), (10, 8), ]) device = NxDevice(topology) class MyLazyCompiler(AbstractCompiler): def quil_to_native_quil(self, program, *, protoquil=None): return program def native_quil_to_executable(self, nq_program): return nq_program my_qc = QuantumComputer( name='my-qvm', qam=QVM(connection=ForestConnection()), device=device, compiler=MyLazyCompiler(),
def mock_qpu_compiler(request, m_endpoints, compiler: QVMCompiler): return QPUCompiler( quilc_endpoint=compiler.client.endpoint, qpu_compiler_endpoint=m_endpoints[0], device=NxDevice(nx.Graph([(0, 1)])), )
def mock_compiler(request, m_endpoints): return QPUCompiler(endpoint=m_endpoints[0], device=NxDevice(nx.Graph([(0, 1)])))
def get_ion_device(num_qubits): return NxDevice(nx.complete_graph(num_qubits))
def get_qc(name: str, *, as_qvm: bool = None, noisy: bool = None, connection: ForestConnection = None): """ Get a quantum computer. A quantum computer is an object of type :py:class:`QuantumComputer` and can be backed either by a QVM simulator ("Quantum/Quil Virtual Machine") or a physical Rigetti QPU ("Quantum Processing Unit") made of superconducting qubits. You can choose the quantum computer to target through a combination of its name and optional flags. There are multiple ways to get the same quantum computer. The following are equivalent:: >>> qc = get_qc("8Q-Agave-noisy-qvm") >>> qc = get_qc("8Q-Agave", as_qvm=True, noisy=True) and will construct a simulator of the 8q-agave chip with a noise model based on device characteristics. We also provide a means for constructing generic quantum simulators that are not related to a given piece of Rigetti hardware:: >>> qc = get_qc("9q-generic-qvm") >>> qc = get_qc("9q-generic", as_qvm=True) Redundant flags are acceptable, but conflicting flags will raise an exception:: >>> qc = get_qc("9q-generic-qvm") # qc is fully specified by its name >>> qc = get_qc("9q-generic-qvm", as_qvm=True) # redundant, but ok >>> qc = get_qc("9q-generic-qvm", as_qvm=False) # Error! Use :py:func:`list_quantum_computers` to retrieve a list of known qc names. This method is provided as a convenience to quickly construct and use QVM's and QPU's. Power users may wish to have more control over the specification of a quantum computer (e.g. custom noise models, bespoke topologies, etc.). This is possible by constructing a :py:class:`QuantumComputer` object by hand. Please refer to the documentation on :py:class:`QuantumComputer` for more information. :param name: The name of the desired quantum computer. This should correspond to a name returned by :py:func:`list_quantum_computers`. Names ending in "-qvm" will return a QVM. Names ending in "-noisy-qvm" will return a QVM with a noise model. Otherwise, we will return a QPU with the given name. :param as_qvm: An optional flag to force construction of a QVM (instead of a QPU). If specified and set to ``True``, a QVM-backed quantum computer will be returned regardless of the name's suffix :param noisy: An optional flag to force inclusion of a noise model. If specified and set to ``True``, a quantum computer with a noise model will be returned regardless of the name's suffix. The noise model for QVM's based on a real QPU is an empirically parameterized model based on real device noise characteristics. The generic QVM noise model is simple T1 and T2 noise plus readout error. See :py:func:`decoherance_noise_with_asymmetric_ro`. :param connection: An optional :py:class:ForestConnection` object. If not specified, the default values for URL endpoints, ping time, and status time will be used. Your user id and API key will be read from ~/.pyquil_config. If you deign to change any of these parameters, pass your own :py:class:`ForestConnection` object. :return: """ if connection is None: connection = ForestConnection() name, as_qvm, noisy = _parse_name(name, as_qvm, noisy) if name == '9q-generic': if not as_qvm: raise ValueError( "The device '9q-generic' is only available as a QVM") nineq_square = nx.convert_node_labels_to_integers( nx.grid_2d_graph(3, 3)) nineq_device = NxDevice(topology=nineq_square) if noisy: noise_model = decoherance_noise_with_asymmetric_ro( nineq_device.get_isa()) else: noise_model = None return QuantumComputer(name='9q-generic-qvm', qam=QVM(connection=connection, noise_model=noise_model), device=nineq_device) # At least based off a real device. device = get_devices(as_dict=True)[name] if not as_qvm: if noisy is not None and noisy: warnings.warn( "You have specified `noisy=True`, but you're getting a QPU. This flag " "is meant for controling noise models on QVMs.") return QuantumComputer(name=name, qam=QPU(device_name=name, connection=connection), device=device) if noisy: noise_model = device.noise_model name = "{name}-noisy-qvm".format(name=name) else: noise_model = None name = "{name}-qvm".format(name=name) return QuantumComputer(name=name, qam=QVM(connection=connection, noise_model=noise_model), device=device)