def generate_rb_sequence(self, depth, gateset, seed=None):
"""
Construct a randomized benchmarking experiment on the given qubits, decomposing into
gateset.
The JSON payload that is parsed is a list of lists of indices, or Nones. In the
former case, they are the index of the gate in the gateset.
:param int depth: The number of Clifford gates to include in the randomized benchmarking
experiment. This is different than the number of gates in the resulting experiment.
:param list gateset: A list of pyquil gates to decompose the Clifford elements into. These
must generate the clifford group on the qubits of interest. e.g. for one qubit
[RZ(np.pi/2), RX(np.pi/2)].
:param seed: A positive integer used to seed the PRNG.
:return: A list of pyquil programs. Each pyquil program is a circuit that represents an
element of the Clifford group. When these programs are composed, the resulting Program
will be the randomized benchmarking experiment of the desired depth. e.g. if the return
programs are called cliffords then `sum(cliffords, Program())` will give the randomized
benchmarking experiment, which will compose to the identity program.
"""
depth = int(depth) # needs to be jsonable, no np.int64 please!
payload = self._rb_sequence_payload(depth, gateset, seed=seed)
response = post_json(self.session, self.endpoint + "/rb",
payload).json()
programs = []
for clifford in response:
clifford_program = Program()
# Like below, we reversed the order because the API currently hands back the Clifford
# decomposition right-to-left.
for index in reversed(clifford):
clifford_program.inst(gateset[index])
programs.append(clifford_program)
# The programs are returned in "textbook style" right-to-left order. To compose them into
# the correct pyquil program, we reverse the order.
return list(reversed(programs))
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()
def apply_clifford_to_pauli(self, clifford, pauli_in):
r"""
Given a circuit that consists only of elements of the Clifford group,
return its action on a PauliTerm.
In particular, for Clifford C, and Pauli P, this returns the PauliTerm
representing PCP^{\dagger}.
:param Program clifford: A Program that consists only of Clifford operations.
:param PauliTerm pauli_in: A PauliTerm to be acted on by clifford via conjugation.
:return: A PauliTerm corresponding to pauli_in * clifford * pauli_in^{\dagger}
"""
payload = self._clifford_application_payload(clifford, pauli_in)
phase_factor, paulis = post_json(self.session,
self.endpoint + "/apply-clifford",
payload).json()
pauli_out = PauliTerm("I", 0, 1.j**phase_factor)
clifford_qubits = clifford.get_qubits()
pauli_qubits = pauli_in.get_qubits()
all_qubits = sorted(set(pauli_qubits).union(set(clifford_qubits)))
# The returned pauli will have specified its value on all_qubits, sorted by index.
# This is maximal set of qubits that can be affected by this conjugation.
for i, pauli in enumerate(paulis):
pauli_out *= PauliTerm(pauli, all_qubits[i])
return pauli_out * pauli_in.coefficient
def expectation(
self,
prep_prog: Program,
operator_programs: Optional[Iterable[Program]] = None
) -> List[float]:
"""
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 prep_prog: Quil program for state preparation.
:param 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.
"""
# 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)
assert self.sync_endpoint is not None
response = post_json(self.session, self.sync_endpoint + "/qvm",
payload)
return cast(List[float], response.json())
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)
