Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/rigetti/reference-qvm
A reference implementation for a quantum virtual machine in Python
https://github.com/rigetti/reference-qvm
forest quantum-simulation quil wavefunction
Last synced: 18 days ago
JSON representation
A reference implementation for a quantum virtual machine in Python
- Host: GitHub
- URL: https://github.com/rigetti/reference-qvm
- Owner: rigetti
- License: apache-2.0
- Archived: true
- Created: 2017-09-26T19:11:48.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2019-02-07T21:13:05.000Z (over 5 years ago)
- Last Synced: 2024-05-13T19:32:12.671Z (about 2 months ago)
- Topics: forest, quantum-simulation, quil, wavefunction
- Language: Python
- Size: 297 KB
- Stars: 45
- Watchers: 14
- Forks: 19
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Lists
- awesome-quantum-software - Quantum Virtual Machine - Reference implementation of Rigetti's Quantum Virtual Machine. (Abandoned projects)
README
[](https://semaphoreci.com/rigetti/reference-qvm)
# Reference QVM
The `referenceqvm` is the reference implementation of the QVM outlined in the
arXiv:1608:03355 by Robert Smith, Spike Curtis, and Will Zeng. It is a research package that
supports rapid prototyping and development of quantum programs using pyQuil.
Currently, this QVM supports a subset of functionality in the Quil specifications,
excepting certain functions (DEFCIRCUIT, WAIT, NOP).
Noise models (dephasing, Kraus operators), parametrization with bits in
classical memory, and other features will be added in future releases.
## Installation
You can install reference-qvm directly from the Python package manager `pip` using:
```
pip install referenceqvm
```
To instead install reference-qvm from source, clone this repository, `cd` into it, and run:
```
pip install -r requirements.txt -e .
```
This will install the reference-qvm's dependencies if you do not already have them.
## Development and Testing
We use tox and pytest for testing. Tests can be executed from the top-level directory by simply
running:
```
tox
```
The setup is currently testing Python 2.7 and Python 3.6.
## Building the Docs
We use sphinx to build the documentation. To do this, navigate into pyQuil's top-level directory and run:
```
sphinx-build -b html ./docs/source ./docs/build
```
To view the docs navigate to the newly-created `docs/build` directory and open
the `index.html` file in a browser. Note that we use the Read the Docs theme for
our documentation, so this may need to be installed using `pip install sphinx_rtd_theme`.
## Interaction with the referenceqvm
The qvm can be accessed in a similar way to the Forest QVM access.
Start by importing the synchronous connection object from the `referenceqvm.api` module
```python
from referenceqvm.api import QVMConnection
```
and initialize a connection to the reference-qvm
```python
qvm = QVMConnection()
```
By default, the Connection object uses the wavefunction transition type.
Then call the `qvm.wavefunction(prog)` method to get back the classical memory and the
pyquil.Wavefunction object given a pyquil.quil.Program object `prog`.
The reference-qvm has the same functionality as Forest QVM and is useful for testing
small quantum programs on a local machine. For example, the same code (up to the
`referenceqvm.api` import) can be used to simulate pyquil programs.
```python
>>> import pyquil.quil as pq
>>> import referenceqvm.api as api
>>> from pyquil.gates import *
>>> qvm = api.QVMConnection()
>>> p = pq.Program(H(0), CNOT(0,1))
>>> qvm.wavefunction(p)[0]
[(0.7071067811865475+0j), 0j, 0j, (0.7071067811865475+0j)]
```
QVMConnection can also initialize a QVM that does not return a wavefunction but instead a unitary corresponding
to the pyquil program. This can be extremely useful in terms of debugging and understanding gate physics. For example,
we can examine the unitary for a CNOT operator.
```python
>>> import pyquil.quil as pq
>>> import referenceqvm.api as api
>>> from pyquil.gates import CNOT
>>> qvm = api.QVMConnection(type_trans='unitary')
>>> p = pq.Program(CNOT(1, 0))
>>> u = qvm.unitary(p)
>>> print(u)
[[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j]
[ 0.+0.j 1.+0.j 0.+0.j 0.+0.j]
[ 0.+0.j 0.+0.j 0.+0.j 1.+0.j]
[ 0.+0.j 0.+0.j 1.+0.j 0.+0.j]]
```
## How to cite the reference-qvm
If you use the reference-qvm please cite the repository as follows:
bibTex:
```
@misc{rqvm2017.0.0.1,
author = {Rigetti Computing",
title = {Reference-QVM},
year = {2017},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {\url{https://github.com/rigetticomputing},
commit = {the commit you used}
}
```
and the paper outlining the Mathematical specification of the quantum-abstract-machine:
bibTeX:
```
@misc{1608.03355,
title={A Practical Quantum Instruction Set Architecture},
author={Smith, Robert S and Curtis, Michael J and Zeng, William J},
journal={arXiv preprint arXiv:1608.03355},
year={2016}
}
```