Pyquil

Announcements

- The Quil Compiler ([quilc](https://github.com/rigetti/quilc)) and
the Quantum Virtual Machine
([QVM](https://github.com/rigetti/quilc)), which are part of the
Forest SDK, have been open sourced! In addition to downloading the
binaries, you can now build these applications locally from source,
or run them via the Docker images
[rigetti/quilc](https://hub.docker.com/r/rigetti/quilc) and
[rigetti/qvm](https://hub.docker.com/r/rigetti/qvm). These Docker
images are now used as the `services` in the GitLab CI build plan
YAML (gh-792, gh-794, gh-795).

Improvements and Changes

- The `WavefunctionSimulator` now supports the use of parametric Quil
programs, via the `memory_map` parameter for its various methods
(gh-787).
- Operator estimation data structures introduced in **v2.2** have
changed. Previously, `ExperimentSettings` had two members:
`in_operator` and `out_operator`. The `out_operator` is unchanged,
but `in_operator` has been renamed to `in_state` and its data type
is now `TensorProductState` instead of `PauliTerm`. It was always an
abuse of notation to interpret pauli operators as defining initial
states. Analogous to the Pauli helper functions sI, sX, sY, and sZ,
`TensorProductState` objects are constructed by multiplying together
terms generated by the helper functions plusX, minusX, plusY,
minusY, plusZ, and minusZ. This functionality enables process
tomography and process DFE (gh-770).
- Operator estimation now offers a \"greedy\" method for grouping
tomography-like experiments that share a natural tensor product
basis (ntpb), as an alternative to the clique cover version
(gh-754).
- The `quilc` endpoint for rewriting Quil parameter arithmetic has
been changed from `resolve_gate_parameter_arithmetic` to
`rewrite_arithmetic` (gh-802).
- The difference between ProtoQuil and QPU-supported Quil is now
better defined (gh-798).

Bugfixes

- Resolved an issue with post-gate noise in the pyQVM (gh-801).
- A `TypeError` with a useful error message is now raised when a
`Program` object is run on a QPU-backed `QuantumComputer`, rather
than a confusing `AttributeError` (gh-799).

constructing and running quantum programs. A major new feature is the
release of a new suite of simulators:

- We\'re proud to introduce the first iteration of a Python-based
quantum virtual machine (QVM) called PyQVM. This QVM is completely
contained within pyQuil and does not need any external dependencies.
Try using it with `get_qc("9q-square-pyqvm")` or explore the
`pyquil.pyqvm.PyQVM` object directly. Under-the-hood, there are
three quantum simulator backends:
- `ReferenceWavefunctionSimulator` uses standard matrix-vector
multiplication to evolve a statevector. This includes a suite of
tools in `pyquil.unitary_tools` for dealing with unitary
matrices.
- `NumpyWavefunctionSimulator` uses numpy\'s tensordot
functionality to efficiently evolve a statevector. For most
simulations, performance is quite good.
- `ReferenceDensitySimulator` uses matrix-matrix multiplication to
evolve a density matrix.
- Matrix representations of Quil standard gates are included in
`pyquil.gate_matrices` (gh-552).
- The density simulator has extremely limited support for
Kraus-operator based noise models. Let us know if you\'re interested
in contributing more robust noise-model support.
- This functionality should be considered experimental and may undergo
minor API changes.

Important changes to note

- Quil math functions (like COS, SIN, \...) used to be ambiguous with
respect to case sensitivity. They are now case-sensitive and should
be uppercase (gh-774).
- In the next release of pyQuil, communication with quilc will happen
exclusively via the rpcq protocol. `LocalQVMCompiler` and
`LocalBenchmarkConnection` will be removed in favor of a unified
`QVMCompiler` and `BenchmarkConnection`. This change should be
transparent if you use `get_qc` and `get_benchmarker`, respectively.
In anticipation of this change we recommend that you upgrade your
version of quilc to 1.3, released Jan 30, 2019 (gh-730).
- When using a paramaterized gate, the QPU control electronics only
allowed multiplying parameters by powers of two. If you only ever
multiply a parameter by the same constant, this isn\'t too much of a
problem because you can fold the multiplicative constant into the
definition of the parameter. However, if you are multiplying the
same variable (e.g. `gamma` in QAOA) by different constants (e.g.
weighted maxcut edge weights) it doesn\'t work. PyQuil will now
transparently handle the latter case by expanding to a vector of
parameters with the constants folded in, allowing you to multiply
variables by whatever you want (gh-707).

Bug fixes and improvements

- The CZ gate fidelity metric available in the Specs object now has
its associated standard error, which is accessible from the method
`Specs.fCZ_std_errs` (gh-751).
- Operator estimation code now correctly handles identity terms with
coefficients. Previously, it would always estimate these terms as
1.0 (gh-758).
- Operator estimation results include the total number of counts
(shots) taken.
- Operator estimation JSON serialization uses utf-8. Please let us
know if this causes problems (gh-769).
- The example quantum die program now can roll dice that are not
powers of two (gh-749).
- The teleportation and Meyer penny game examples had a syntax error
(gh-778, gh-772).
- When running on the QPU, you could get into trouble if the QPU name
passed to `get_qc` did not match the lattice you booked. This is now
validated (gh-771).

We extend thanks to community member estamm12 for their contribution to
this release.

constructing and running quantum programs. Bug fixes and improvements
include:

- `pauli.is_zero` and `paulis.is_identity` would sometimes return
erroneous answers (gh-710).
- Parameter expressions involving addition and subtraction are now
converted to Quil with spaces around the operators, e.g. `theta + 2`
instead of `theta+2`. This disambiguates subtracting two parameters,
e.g. `alpha - beta` is not one variable named `alpha-beta` (gh-743).
- T1 is accounted for in T2 noise models (gh-745).
- Documentation improvements (gh-723, gh-719, gh-720, gh-728, gh-732,
gh-742).
- Support for PNG generation of circuit diagrams via LaTeX (gh-745).
- We\'ve started transitioning to using Gitlab as our continuous
integration provider for pyQuil (gh-741, gh-752).

This release includes a new module for facilitating the estimation of
quantum observables/operators (gh-682). First-class support for
estimating observables should make it easier to express near-term
algorithms. This release includes:

- data structures for expressing tomography-like experiments and their
results
- grouping of experiment settings that can be simultaneously estimated
- functionality to executing a tomography-like experiment on a quantum
computer

Please look forward to more features and polish in future releases.
Don\'t hesitate to submit feedback or suggestions as GitHub issues.

We extend thanks to community member petterwittek for their contribution
to this release.

Bugfix release 2.2.1 was released January 11 to maintain compatibility
with the latest version of the quilc compiler (gh-759).

constructing and running quantum programs. Changes include:

- Major documentation improvements.
- `QuantumComputer.run()` accepts an optional `memory_map` parameter
to facilitate running parametric executables (gh-657).
- `QuantumComputer.reset()` will reset the state of a QAM to recover
from an error condition (gh-703).
- Bug fixes (gh-674, gh-696).
- Quil parser improvements (gh-689, gh-685).
- Optional interleaver argument when generating RB sequences (gh-673).
- Our GitHub organization name has changed from `rigetticomputing` to
`rigetti` (gh-713).

documentation changes only. This release is only available as a git tag.
We have not pushed a new package to PyPI.

constructing and running quantum programs. This release contains many
major changes including:

1. The introduction of [Quantum Cloud
Services](https://www.rigetti.com/qcs). 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. Please read the documentation on what is [New in Forest
2](https://pyquil.readthedocs.io/en/stable/migration4.html) for a
comprehensive migration guide.

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 [New in Forest
2](https://pyquil.readthedocs.io/en/stable/migration4.html) 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.