def _get_qvm_compiler_based_on_endpoint(endpoint=None, device=None):
if endpoint.startswith("http"):
return LocalQVMCompiler(endpoint=endpoint, device=device)
elif endpoint.startswith("tcp"):
return QVMCompiler(endpoint=endpoint, device=device)
else:
raise ValueError(
"Protocol for QVM compiler endpoints must be HTTP or TCP.")
def __init__(self, device=None, endpoint=None,
gate_noise=None, measurement_noise=None, random_seed=None,
compiler_endpoint=None):
"""
Constructor for QVMConnection. Sets up any necessary security, and establishes the noise
model to use.
:param Device device: The optional device, from which noise will be added by default to all
programs run on this instance.
:param endpoint: The endpoint of the server for running small jobs
:param gate_noise: A list of three numbers [Px, Py, Pz] indicating the probability of an X,
Y, or Z gate getting applied to each qubit after a gate application or
reset. (default None)
:param measurement_noise: A list of three numbers [Px, Py, Pz] indicating the probability of
an X, Y, or Z gate getting applied before a a measurement.
(default None)
:param random_seed: A seed for the QVM's random number generators. Either None (for an
automatically generated seed) or a non-negative integer.
"""
if endpoint is None:
pyquil_config = PyquilConfig()
endpoint = pyquil_config.qvm_url
if compiler_endpoint is None:
pyquil_config = PyquilConfig()
compiler_endpoint = pyquil_config.compiler_url
if (device is not None and device.noise_model is not None) and \
(gate_noise is not None or measurement_noise is not None):
raise ValueError("""
You have attempted to supply the QVM with both a device noise model
(by having supplied a device argument), as well as either gate_noise
or measurement_noise. At this time, only one may be supplied.
To read more about supplying noise to the QVM, see http://pyquil.readthedocs.io/en/latest/noise_models.html#support-for-noisy-gates-on-the-rigetti-qvm.
""")
if device is not None and device.noise_model is None:
warnings.warn("""
You have supplied the QVM with a device that does not have a noise model. No noise will be added to
programs run on this QVM.
""")
self.noise_model = device.noise_model if device else None
self.compiler = LocalQVMCompiler(endpoint=compiler_endpoint, device=device) if device \
else None
self.sync_endpoint = endpoint
validate_noise_probabilities(gate_noise)
validate_noise_probabilities(measurement_noise)
self.gate_noise = gate_noise
self.measurement_noise = measurement_noise
if random_seed is None:
self.random_seed = None
elif isinstance(random_seed, integer_types) and random_seed >= 0:
self.random_seed = random_seed
else:
raise TypeError("random_seed should be None or a non-negative int")
self._connection = ForestConnection(sync_endpoint=endpoint)
self.session = self._connection.session # backwards compatibility
class QVMConnection(object):
"""
Represents a connection to the QVM.
"""
@_record_call
def __init__(self, device=None, endpoint=None,
gate_noise=None, measurement_noise=None, random_seed=None,
compiler_endpoint=None):
"""
Constructor for QVMConnection. Sets up any necessary security, and establishes the noise
model to use.
:param Device device: The optional device, from which noise will be added by default to all
programs run on this instance.
:param endpoint: The endpoint of the server for running small jobs
:param gate_noise: A list of three numbers [Px, Py, Pz] indicating the probability of an X,
Y, or Z gate getting applied to each qubit after a gate application or
reset. (default None)
:param measurement_noise: A list of three numbers [Px, Py, Pz] indicating the probability of
an X, Y, or Z gate getting applied before a a measurement.
(default None)
:param random_seed: A seed for the QVM's random number generators. Either None (for an
automatically generated seed) or a non-negative integer.
"""
if endpoint is None:
pyquil_config = PyquilConfig()
endpoint = pyquil_config.qvm_url
if compiler_endpoint is None:
pyquil_config = PyquilConfig()
compiler_endpoint = pyquil_config.compiler_url
if (device is not None and device.noise_model is not None) and \
(gate_noise is not None or measurement_noise is not None):
raise ValueError("""
You have attempted to supply the QVM with both a device noise model
(by having supplied a device argument), as well as either gate_noise
or measurement_noise. At this time, only one may be supplied.
To read more about supplying noise to the QVM, see http://pyquil.readthedocs.io/en/latest/noise_models.html#support-for-noisy-gates-on-the-rigetti-qvm.
""")
if device is not None and device.noise_model is None:
warnings.warn("""
You have supplied the QVM with a device that does not have a noise model. No noise will be added to
programs run on this QVM.
""")
self.noise_model = device.noise_model if device else None
self.compiler = LocalQVMCompiler(endpoint=compiler_endpoint, device=device) if device \
else None
self.sync_endpoint = endpoint
validate_noise_probabilities(gate_noise)
validate_noise_probabilities(measurement_noise)
self.gate_noise = gate_noise
self.measurement_noise = measurement_noise
if random_seed is None:
self.random_seed = None
elif isinstance(random_seed, integer_types) and random_seed >= 0:
self.random_seed = random_seed
else:
raise TypeError("random_seed should be None or a non-negative int")
self._connection = ForestConnection(sync_endpoint=endpoint)
self.session = self._connection.session # backwards compatibility
@_record_call
def get_version_info(self):
"""
Return version information for the QVM.
:return: Dictionary with version information
"""
return self._connection._qvm_get_version_info()
@_record_call
def run(self, quil_program, classical_addresses: List[int] = None,
trials=1):
"""
Run a Quil program multiple times, accumulating the values deposited in
a list of classical addresses.
:param Program quil_program: A Quil program.
:param classical_addresses: The classical memory to retrieve. Specified as a list of
integers that index into a readout register named ``ro``. This function--and
particularly this argument--are included for backwards compatibility and will
be removed in the future.
:param int trials: Number of shots to collect.
:return: A list of dictionaries of bits. Each dictionary corresponds to the values in
`classical_addresses`.
:rtype: list
"""
if classical_addresses is None:
caddresses = get_classical_addresses_from_program(quil_program)
else:
caddresses = {'ro': classical_addresses}
buffers = self._connection._qvm_run(quil_program, caddresses, trials,
self.measurement_noise, self.gate_noise,
self.random_seed)
if len(buffers) == 0:
return []
if 'ro' in buffers:
return buffers['ro'].tolist()
raise ValueError("You are using QVMConnection.run with multiple readout registers not "
"named `ro`. Please use the new `QuantumComputer` abstraction.")
@_record_call
def run_and_measure(self, quil_program, qubits, trials=1):
"""
Run a Quil program once to determine the final wavefunction, and measure multiple times.
:note: If the execution of ``quil_program`` is **non-deterministic**, i.e., if it includes
measurements and/or noisy quantum gates, then the final wavefunction from which the
returned bitstrings are sampled itself only represents a stochastically generated sample
and the outcomes sampled from *different* ``run_and_measure`` calls *generally sample
different bitstring distributions*.
:param Program quil_program: A Quil program.
:param list|range qubits: A list of qubits.
:param int trials: Number of shots to collect.
:return: A list of a list of bits.
:rtype: list
"""
# Developer note: This code is for backwards compatibility. It can't be replaced with
# ForestConnection._run_and_measure because we've turned off the ability to set
# `needs_compilation` (that usually indicates the user is doing something iffy like
# using a noise model with this function)
payload = self._run_and_measure_payload(quil_program, qubits, trials)
response = post_json(self.session, self.sync_endpoint + "/qvm", payload)
return response.json()
@_record_call
def _run_and_measure_payload(self, quil_program, qubits, trials):
if not quil_program:
raise ValueError("You have attempted to run an empty program."
" Please provide gates or measure instructions to your program.")
if not isinstance(quil_program, Program):
raise TypeError("quil_program must be a Quil program object")
qubits = validate_qubit_list(qubits)
if not isinstance(trials, integer_types):
raise TypeError("trials must be an integer")
if self.noise_model is not None:
compiled_program = self.compiler.quil_to_native_quil(quil_program)
quil_program = apply_noise_model(compiled_program, self.noise_model)
payload = {"type": TYPE_MULTISHOT_MEASURE,
"qubits": list(qubits),
"trials": trials,
"compiled-quil": quil_program.out()}
self._maybe_add_noise_to_payload(payload)
self._add_rng_seed_to_payload(payload)
return payload
@_record_call
def wavefunction(self, quil_program):
"""
Simulate a Quil program and get the wavefunction back.
:note: If the execution of ``quil_program`` is **non-deterministic**, i.e., if it includes
measurements and/or noisy quantum gates, then the final wavefunction from which the
returned bitstrings are sampled itself only represents a stochastically generated sample
and the wavefunctions returned by *different* ``wavefunction`` calls *will generally be
different*.
:param Program quil_program: A Quil program.
:return: A Wavefunction object representing the state of the QVM.
:rtype: Wavefunction
"""
# Developer note: This code is for backwards compatibility. It can't be replaced with
# ForestConnection._wavefunction because we've turned off the ability to set
# `needs_compilation` (that usually indicates the user is doing something iffy like
# using a noise model with this function)
payload = self._wavefunction_payload(quil_program)
response = post_json(self.session, self.sync_endpoint + "/qvm", payload)
return Wavefunction.from_bit_packed_string(response.content)
@_record_call
def _wavefunction_payload(self, quil_program):
# Developer note: This code is for backwards compatibility. It can't be replaced with
# _base_connection._wavefunction_payload because we've turned off the ability to set
# `needs_compilation` (that usually indicates the user is doing something iffy like
# using a noise model with this function)
if not isinstance(quil_program, Program):
raise TypeError("quil_program must be a Quil program object")
payload = {'type': TYPE_WAVEFUNCTION,
'compiled-quil': quil_program.out()}
self._maybe_add_noise_to_payload(payload)
self._add_rng_seed_to_payload(payload)
return payload
@_record_call
def expectation(self, prep_prog, operator_programs=None):
"""
Calculate the expectation value of operators given a state prepared by
prep_program.
:note: If the execution of ``quil_program`` is **non-deterministic**, i.e., if it includes
measurements and/or noisy quantum gates, then the final wavefunction from which the
expectation values are computed itself only represents a stochastically generated
sample. The expectations returned from *different* ``expectation`` calls *will then
generally be different*.
To measure the expectation of a PauliSum, you probably want to
do something like this::
progs, coefs = hamiltonian.get_programs()
expect_coeffs = np.array(cxn.expectation(prep_program, operator_programs=progs))
return np.real_if_close(np.dot(coefs, expect_coeffs))
:param Program prep_prog: Quil program for state preparation.
:param list operator_programs: A list of Programs, each specifying an operator whose expectation to compute.
Default is a list containing only the empty Program.
:return: Expectation values of the operators.
:rtype: List[float]
"""
# Developer note: This code is for backwards compatibility. It can't be replaced with
# ForestConnection._expectation because we've turned off the ability to set
# `needs_compilation` (that usually indicates the user is doing something iffy like
# using a noise model with this function)
if isinstance(operator_programs, Program):
warnings.warn(
"You have provided a Program rather than a list of Programs. The results from expectation "
"will be line-wise expectation values of the operator_programs.", SyntaxWarning)
payload = self._expectation_payload(prep_prog, operator_programs)
response = post_json(self.session, self.sync_endpoint + "/qvm", payload)
return response.json()
@_record_call
def pauli_expectation(self, prep_prog, pauli_terms):
"""
Calculate the expectation value of Pauli operators given a state prepared by prep_program.
If ``pauli_terms`` is a ``PauliSum`` then the returned value is a single ``float``,
otherwise the returned value is a list of ``float``s, one for each ``PauliTerm`` in the
list.
:note: If the execution of ``quil_program`` is **non-deterministic**, i.e., if it includes
measurements and/or noisy quantum gates, then the final wavefunction from which the
expectation values are computed itself only represents a stochastically generated
sample. The expectations returned from *different* ``expectation`` calls *will then
generally be different*.
:param Program prep_prog: Quil program for state preparation.
:param Sequence[PauliTerm]|PauliSum pauli_terms: A list of PauliTerms or a PauliSum.
:return: If ``pauli_terms`` is a PauliSum return its expectation value. Otherwise return
a list of expectation values.
:rtype: float|List[float]
"""
is_pauli_sum = False
if isinstance(pauli_terms, PauliSum):
progs, coeffs = pauli_terms.get_programs()
is_pauli_sum = True
else:
coeffs = [pt.coefficient for pt in pauli_terms]
progs = [pt.program for pt in pauli_terms]
bare_results = self.expectation(prep_prog, progs)
results = [c * r for c, r in zip(coeffs, bare_results)]
if is_pauli_sum:
return sum(results)
return results
def _expectation_payload(self, prep_prog, operator_programs):
if operator_programs is None:
operator_programs = [Program()]
if not isinstance(prep_prog, Program):
raise TypeError("prep_prog variable must be a Quil program object")
payload = {'type': TYPE_EXPECTATION,
'state-preparation': prep_prog.out(),
'operators': [x.out() for x in operator_programs]}
self._add_rng_seed_to_payload(payload)
return payload
def _maybe_add_noise_to_payload(self, payload):
"""
Set the gate noise and measurement noise of a payload.
"""
if self.measurement_noise is not None:
payload["measurement-noise"] = self.measurement_noise
if self.gate_noise is not None:
payload["gate-noise"] = self.gate_noise
def _add_rng_seed_to_payload(self, payload):
"""
Add a random seed to the payload.
"""
if self.random_seed is not None:
payload['rng-seed'] = self.random_seed