pyQuil 2.0

PyQuil 2.0 is a major release of pyQuil, Rigetti's toolkit for constructing and running quantum
programs. This release contains many major changes including:

1. The introduction of Quantum Cloud Services. Access
   Rigetti's QPUs from co-located classical compute resources for minimal latency. The
   web API for running QVM and QPU jobs has been deprecated and cannot be accessed with
   pyQuil 2.0
2. Advances in classical control systems and compilation allowing the pre-compilation of
   parametric binary executables for rapid hybrid algorithm iteration.
3. Changes to Quil---our quantum instruction language---to provide easier ways of
   interacting with classical memory.

The new QCS access model and features will allow you to execute hybrid quantum algorithms
several orders of magnitude (!) faster than the previous web endpoint. However, to fully
exploit these speed increases you must update your programs to use the latest pyQuil features
and APIs.

An incomplete list of significant changes:

• Python 2 is no longer supported. Please use Python 3.6+
• Parametric gates are now normal functions. You can no longer write RX(pi/2)(0) to get a
  Quil RX(pi/2) 0 instruction. Just use RX(pi/2, 0).
• Gates support keyword arguments, so you can write RX(angle=pi/2, qubit=0).
• All async methods have been removed from QVMConnection and QVMConnection is
  deprecated. QPUConnection has been removed in accordance with the QCS access model.
  Use pyquil.get_qc as the primary means of interacting with the QVM or QPU.
• WavefunctionSimulator allows unfettered access to wavefunction properties and routines.
  These methods and properties previously lived on QVMConnection and have been deprecated
  there.
• Classical memory in Quil must be declared with a name and type. Please read :ref:quickstart
  for more.
• Compilation has changed. There are now different Compiler objects that target either the
  QPU or QVM. You must explicitly compile your programs to run on a QPU or a realistic QVM.

pyQuil 1.9

We’re happy to announce the release of pyQuil 1.9. PyQuil is Rigetti’s toolkit for constructing and running quantum programs. This release is the latest in our series of regular releases, and it’s filled with convenience features, enhancements, bug fixes, and documentation improvements.

Special thanks to community members sethuiyer, vtomole, rht, akarazeev, ejdanderson, markf94, playadust, and kadora626 for contributing to this release!

Qubit placeholders

One of the focuses of this release is a re-worked concept of "Qubit Placeholders". These are logical qubits that can be used to construct programs. Now, a program containing qubit placeholders must be "addressed" prior to running on a QPU or QVM. The addressing stage involves mapping each qubit placeholder to a physical qubit (represented as an integer). For example, if you have a 3 qubit circuit that you want to run on different sections of the Agave chip, you now can prepare one Program and address it to many different subgraphs of the chip topology. Check out the QubitPlaceholder example notebook for more.

To support this idea, we've refactored parts of pyQuil to remove the assumption that qubits can be "sorted". While true for integer qubit labels, this probably isn't true in general. A notable change can be found in the construction of a PauliSum: now terms will stay in the order they were constructed.

• PauliTerm now remembers the order of its operations. sX(1)*sZ(2) will compile to different Quil code than sZ(2)*sX(1), although the terms will still be equal according to the __eq__ method. During PauliSum combination of like terms, a warning will be emitted if two terms are combined that have different orders of operation.
• PauliTerm.id() takes an optional argument sort_ops which defaults to True for backwards compatibility. However, this function should not be used for comparing term-type like it has been used previously. Use PauliTerm.operations_as_set() instead. In the future, sort_ops will default to False and will eventually be removed.
• Program.alloc() has been deprecated. Please instantiate QubitPlaceholder() directly or request a "register" (list) of n placeholders by using the class constructor QubitPlaceholder.register(n).
• Programs must contain either (1) all instantiated qubits with integer indexes or (2) all placeholder qubits of type QubitPlaceholder. We have found that most users use (1) but (2) will become useful with larger and more diverse devices.
• Programs that contain qubit placeholders must be explicitly addressed prior to execution. Previously, qubits would be assigned "under the hood" to integers 0...N. Now, you must use address_qubits which returns a new program with all qubits indexed depending on the qubit_mapping argument. The original program is unaffected and can be "readdressed" multiple times.
• PauliTerm can now accept QubitPlaceholder in addition to integers.
• QubitPlaceholder is no longer a subclass of Qubit. LabelPlaceholder is no longer a subclass of Label.
• QuilAtom subclasses' hash functions have changed.

Randomized benchmarking sequence generation

PyQuil now includes support for performing a simple benchmarking routine - randomized benchmarking. There is a new method in the CompilerConnection that will return sequences of pyQuil programs, corresponding to elements of the Clifford group. These programs are uniformly randomly sampled, and have the property that they compose to the identity. When concatenated and run as one program, these programs can be used in a procedure called randomized benchmarking to gain insight about the fidelity of operations on a QPU.

In addition, the CompilerConnection has another new method, apply_clifford_to_pauli, which conjugates PauliTerms by Programs that are composed of Clifford gates. That is to say, given a circuit C, that contains only gates corresponding to elements of the Clifford group, and a tensor product of elements P, from the Pauli group, this method will compute $PCP^{dagger}$. Such a procedure can be used in various ways. An example is predicting the effect a Clifford circuit will have on an input state modeled as a density matrix, which can be written as a sum of Pauli matrices.

Ease of Use

This release includes some quality-of-life improvements such as the ability to initialize programs with generator expressions, sensible defaults for Program.measure_all, and sensible defaults for classical_addresses in run methods.

• Program can be initiated with a generator expression.
• Program.measure_all (with no arguments) will measure all qubits in a program.
• classical_addresses is now optional in QVM and QPU run methods. By default, any classical addresses targeted by MEASURE will be returned.
• QVMConnection.pauli_expectation accepts PauliSum as arguments. This offers a more sensible API compared to QVMConnection.expectation.
• PyQuil will now retry jobs every 10 seconds if the QPU is re-tuning.
• CompilerConnection.compile now takes an optional argument isa that allows per-compilation specification of the target ISA.
• An empty program will trigger an exception if you try to run it.

Supported versions of Python

We strongly support using Python 3 with pyQuil. Although this release works with Python 2, we are dropping official support for this legacy language and moving to community support for Python 2. The next major release of pyQuil will introduce Python 3.5+ only features and will no longer work without modification for Python 2.

Bug fixes

• shift_quantum_gates has been removed. Users who relied on this functionality should use QubitPlaceholder and address_qubits to achieve the same result. Users should also double-check data resulting from use of this function as there were several edge cases which would cause the shift to be applied incorrectly resulting in badly-addressed qubits.
• Slightly perturbed angles when performing RX gates under a Kraus noise model could result in incorrect behavior.
• The quantum die example returned incorrect values when n = 2^m.

v1.8.0

Corresponding milestone: https://github.com/rigetticomputing/pyquil/milestone/3

• Added the CompilerConnection standalone endpoint to allow users to investigate compiling to different hardware architectures
• Enabled the run functionality for QPUConnection, to make it easier to port code between the QVM and QPU
• Added the NoiseModel class for constructing noise models on the QVM
• Enhanced the Device class with Specs, ISA (instruction set architecture), and NoiseModel information regarding the QPU to which the device corresponds
• Enabled providing a Device as an argument to a QVMConnection, for easily constructing a QVM with that device's noise model

Grove release v1.6.0: https://github.com/rigetticomputing/grove/releases/tag/v1.6.0

Release 1.1.2

Bugfixes and performance improvements.

Added powers of PauliSum and PauliTerm

Release v1.1.1

This release incorporates some minor bugfixes and enables PyPi downloads again.

Release v1.1.0

This release:

• Officially introduces Python >=3.6 compatibility!
• Fixes some small bugs in the QPUConnection object
• Adds an inverse method that allows you to dagger pyQuil programs (#51)

Release v1.0.0

This is the public beta release of pyQuil!

Highlights include:

• The addition of the JobConnection object that allow batch jobs to be run.
• The addition of the QPUConnection object that allows Rabi, Ramsey, and T1 experiments to be run on quantum hardware
• Backwards compatible synchronous QVM jobs are now run using the SyncConnection object.
• A plots.py module was added for plotting and fitting of QPU experimental data.

Release v0.1.0

Numerous bug fixes. A breaking change in introducing the Wavefunction object causes a bump to v0.1.0. This release includes:

• Introduction of the Wavefunction object that can be pretty-printed as kets
• Library made both Python 3 and Python 2.7 compatible
• pyQuil program objects are now iterable
• PauliSums and PauliTerms are iterable and can be subtracted
• The Meyer-penny game example

Release v0.0.3

• Several bug fixes and smoothing of the installation procedure.
• Add extract_qubits method to a pyQuil program
• Adds a run_quil.py script that executes raw Quil code against the API.

Release v0.0.2

This downloadable release of pyQuil is for constructing Quil programs and connecting to Rigetti Forest.