PyZX is a Python library for quantum circuit optimisation and compiling using the ZX-calculus. It's great for hacking, learning, and trying things out in Jupyter notebooks. However, it's written to maximise clarity and fun, not performance.
This is a port of some of the core functionality of PyZX to the Rust programming language. This is a modern systems programming language, which enables writing software that is very fast and memory efficient.
To build from source, first get Rust, then use the included package and build manager cargo
.
git clone https://github.com/Quantomatic/quizx.git
cd quizx
cargo build
cargo test
This will download the dependendies, build in debug mode and run the tests. There is a miscellaneous collection of programs written using the library, found in src/bin
. To build in release (i.e. fast) mode, run:
cargo build --release
Then, run one of the binaries via the cargo run
command, or directly via e.g.
cd target/release
./spider_chain
As a very anecdotal example of the performance difference, the program spider_chain
builds a chain of 1 million green spiders and fuses them all. In PyZX, you can fuse all the spiders in a ZX-diagram as follows:
from pyzx.basicrules import *
success = True
while success
success = any(fuse(g, g.edge_s(e), g.edge_t(e)) for e in g.edges()):
In QuiZX, the Rust code is slightly more verbose, but similar in spirit:
use quizx::basic_rules::*;
loop {
match g.find_edge(|v0,v1,_| check_spider_fusion(&g, v0, v1)) {
Some((v0,v1,_)) => spider_fusion_unsafe(&mut g, v0, v1),
None => break,
};
}
On my laptop, the PyZX code takes about 98 seconds to fuse 1 million spiders, whereas the QuiZX code takes 17 milliseconds.
QuiZX is very much a work in progress. It is not intended to have all the features of PyZX, but certainly the core stuff. Here's where it's at:
- ZX-diagrams
- building ZX-diagrams and doing basic graph manipulations
- converting ZX-diagrams to Z + hadamard form
- switchable underlying graph model (fast vector-based model for sparse graphs, slower hash-based model for dense graphs)
- ZX-calculus rules
- spider fusion
- local complementation
- pivoting
- remove identity spiders
- colour-change
- pivoting variations (boundary-pivot and gadget-pivot)
- simplifiers
- tensor evaluation based on ndarray
- exact scalars with cyclotomic rational numbers
- floating point scalars based on num_complex
- tensor contraction for arbitrary ZX-diagrams
- equality of tensors with exact scalars
- approximate equality of tensors with floating point scalars
- space optimisations
- choose good contraction ordering (currently uses reverse-insertion-order)
- more human-readable tensor output (e.g. converting to normal matrices, pretty printing)
- circuits
- circuit data type
- read and write QASM
- conversion from circuits to ZX-diagrams
- circuit extraction (working, but buggy)
Pull requests are welcome!