Variation Quantum Factoring
This repository contains implementation of the algorithm presented in the article "Variational Quantum Factoring", by Eric R. Anschuetz, Jonathan P. Olson, Alán Aspuru-Guzik, Yudong Cao. It's available on arxiv.
The notation in the code refers directly to the notation in the paper.
This project relies heavily on
grove libraries. Unfortunately, at the time I was developing this project, released versions had bugs that were critical for this project.
Therefore, I've installed them from source:
- pyquil, commit-sha:
- grove, commit-sha:
All the packages that don't get installed automatically during instalation of pyquil and grove are listed in the
List of all the installed packages that has been used for this project can be found in
Differences from the paper
Below you can find a list of points where I'm aware that my implementation differs from the one provided in the paper.
- To perform simulations I decided to use pyQuil instead of QuTiP.
- Number of preprocessing rules is higher than what comes from the equations (5) in the paper, since some of them were not stated explicitly ("trivial relations").
- The results suggest that this script does more preprocessing than what has been done in the paper.
- Algorithm can be ran with (as in paper, see footnote 38) or without prior knowledge about the length of the numbers p and q.
- In order to use custom preprocessing rules for numbers 56153 and 291311 (see footnote 40), specific functions must be called. Otherwise, the regular preprocessing scheme will be applied.
- The grid size used for the initialization of BFGS algorithm (Table I in the paper) has been chosen arbitrary. Therefore I have also used arbitrary grid size - it might be too low in some cases, depending on the number being factored. Make sure you choose the right parameter here.
- Implementation of the BFGS algorithm is different from the one used in the original paper (see report in
- I'm not 100% sure if the "layer-by-layer iterative brute-force grid search" I've implemented is the same as the one used by the authors (Sec. III in the paper).
Research performed using this implementation can be found in the
research directory. I follow the convention presented here.
To run tests please run
python -m pytest from the main directory.
Randomness in results
For some reason, the preprocessing is not deterministic. Running the same case sporadically leads to getting different results. It seems to come from the fact, that there is some randomness inside sympy when it comes to ordering operations. Hence, preprocessing sometimes assigns
x=y and sometimes
y=x, which leads to different expressions after substition. From the mathematical point of view it doesn't matter, but from the practical - it does. Since set of implemented rules is incomplete, different substitution may occasionally lead to form which this algorithm cannot simplify. This effect diminished over time of development - i.e. improving rules and fixing bugs.
I do not claim that the preprocessing part is perfect, though from manual inspection it seems to be working in most cases. Below are some known bugs.
- Current version of code doesn't produce correct results for number 1465 (factors: 293 and 5). This doesn't happen always (see note about randomness above).
- There are still some additional rules to add / cases to fix (see TODO in
- In cases exhibiting some form of symmetry (as described here), procedure of calculating squared overlap might give wrong results. The fix for numbers 56153 and 291311, has been hardcoded, but it's far from being elegant and general solution.