Advances in algorithms have driven the field of computer vision research forward and led to significant improvements in performance over the years. However, the nature of those algorithms is heavily influenced by the underlying hardware. A wide body of work, including seminal papers on edge detection  and optical flow  started with single core CPUs. The introduction of multi-core CPU’s led to new real-time computer vision systems 
. More recently, advances in GPU’s motivated researchers to revisit the idea of neural networks, leading to the widespread adoption of deep learning.
As we approach the end of Moore’s Law , researchers and hardware manufacturers are actively investigating alternative computing paradigms. Alternative hardware includes visual processing units, neuromorphic, optical, biological and quantum computers [6, 7, 8, 9, 10, 11]. Quantum computers hold significant promise as they can have polynomial and exponential speed-ups on some problems [12, 13]. This increase in processing power could have a fundamental impact on computer vision.
Small-scale, commercial quantum computers are becoming increasingly available. The challenge for the computer vision community is to identify or create algorithms that are well suited to quantum computing and can exploit potential benefits. Unfortunately, this is non-trivial for three reasons. Firstly, quantum computers use qubits instead of bits, which is a fundamentally different way of storing and processing data. Furthermore, existing quantum computers and quantum emulators can only process a very small amount of data, making it challenging to design and test algorithms. Finally, current and near term quantum computers will be noisy and algorithms should be robust to noise.
This paper proposes a novel method for image segmentation that is a natural fit for quantum computation, is robust to noise and can be run on current and near-term quantum computers. The graph cut image segmentation methods of max-flow min-cut and normalized cuts are mapped to the Quantum Approximation Optimization Algorithm (QAOA) . QAOA is an attractive choice for its resilience to systematic noise  and its realizability on current quantum devices. The paper demonstrates a practical application for quantum algorithms in the field of computer vision and provides image segmentation results on synthetic and medical images. The methods work on current computers and can scale as larger computers become available.
Quantum computing will open up new research areas in computer vision and lead to the revisiting of existing techniques. This paper is a first step towards ever more sophisticated computer vision algorithms for the new promising quantum hardware.
2 Related Work
Performing computer vision tasks on a quantum device is a novel concept. To our knowledge, this is the first implementation of image segmentation with a quantum algorithm. Nevertheless, there have been previous implementations on other image recognition tasks with quantum approaches. Several works [16, 17, 18, 19] have implemented image classification with quantum devices, including quantum annealers. These use a different framework to the gate-based devices that are discussed in this work. Image matching has also been investigated with the quantum annealer . Moreover, quantum-inspired classical approaches have been used in image segmentation  and edge-detection [21, 22]. These still make use of classical computers, although they take inspiration from quantum concepts. Finally, a proposed algorithm promises an exponential speed-up for edge detection , however requires improvements in quantum hardware beyond what is currently available. This work differs from the latter as it is a near-term approach that is already feasible now on current devices.
Related to QAOA, there has been previous work on graph cut problems, in particular the unweighted MaxCut problem on 3-regular graphs . This gave cuts that were less optimal than the best classical algorithm. However, the results are expected to improve with larger (see Section 3.2), which the author has left unexplored. Other theoretical work includes the contributions by Wang et al. , who have obtained analytical expressions for the QAOA objective function for several specific cases. Weighted MaxCut problems have also been investigated with QAOA prior to this work for finding clusters in data .
3.1 Introduction to Quantum Computation
Current algorithms for classical computers involve high-level instructions, as the field has matured to the stage that programming can be performed without considering the operations of gates and circuits. However, the situation is different for quantum computers, as the infrastructure for this luxury has not yet been set in place. Therefore, algorithms described for quantum computers still include concepts such as bits, gates and circuits.
Within the quantum computation paradigm, qubits replace bits as the building blocks of information. Within this framework, qubits are denoted “states”. Analogously to the classical bits, the quantum bits and
exist. These can respectively be written in vector notation as the following:and . These vectors form a basis in , and this is commonly referred to as the computational basis.
Quantum states cannot be known unless measured. This is analogous to reading the bits in classical computation. Prior to a measurement, the state would be in a superposition, which is a linear combination of the and states. More precisely, a state in superposition is given by , where . Using the vector notation for and , it can be expressed as a vector
. The physical meaning of this is that the qubit, when measured, will yield “0” with probabilityand “1” with probability . For normalization purposes, . A curious feature of quantum mechanics is that measurement inherently changes and destroys the state, so that a result of “0” transforms the initial state to become .
In quantum computation, states are “evolved” to other states using gates. A gate is therefore a mapping from one state to another, and can be expressed as a unitary matrix. Universal sets of gates exist, so that any gate can be decomposed into a combination of elements from a given set. These sets are analogous to thenand gate in classical computation. Useful operators for our discussion are the Pauli , and operators: , , . The operator makes the transformation , the does the same up to a complex phase, and the imparts a negative sign on the state, whilst leaving the state unchanged. Together with the identity operator, these operators form a basis for the complex matrices. Another important class of operators is that of Hamiltonians
. These have real eigenvalues that correspond to the energies of its eigenstates.
The notation indicates the Hermitian conjugate of the state , so that for . It lives in the dual vector space to that of , so that forms an inner product, given by . The visually similar , on the other hand, is the outer product of the vectors, giving a matrix. For a more rigorous and detailed introduction to quantum computation, please see .
3.2 Outline of QAOA
In QAOA, the aim is to optimize objective functions that come from combinatorial optimization. These objective functions are typically sums of constraints and maximized with respect to a bit string. In the quantum setting, the objective function can be encoded as a Hamiltonian , with a matrix representation that is diagonal in the computational basis . For instance, in the setting of two qubits, becomes
This operator has eigenvectors given bywith corresponding eigenvalues . Maximizing the classical objective function then corresponds to finding the eigenstate that gives the largest eigenvalue or energy.
The strategy of QAOA is to start with the highest eigenstate of a Hamiltonian , which should be easy to construct, and to evolve this state appropriately to the highest eigenstate of . As the real evolution between the two states is unknown, we apply an approximate unitary that asymptotically converges to the real unitary operator. Making use of the approximate unitary means that one can only expect to obtain the final evolved state that has a high overlap with the actual eigenstate . The initial Hamiltionian, also called the driver Hamiltonian , is often the sum of one qubit Pauli matrices,
The eigenstate with the largest eigenvalue is simply an equally weighted superposition of the basis states: . Equivalently, it is the state , which can be easily constructed with the Hadamard gate applied on each qubit. The superscript denotes an
-fold tensor product and the Hadamard gate has the matrix representation:The unitary operator that is used to evolve from to , so that can be written in terms of the two Hamiltonians:
where and are sets of angles. Indeed, the angles in are periodic in and the angles in have a period of . In the implementation, these angles are initialized uniformly at random within the first period.
The objective function is defined as :
This is optimized with respect to the angles and , to find . Since this state should have a large overlap with , measuring this state multiple times allows us to obtain the most frequent bitstring, that is hopefully equal to the optimal bitstring. The bitstring encodes the segmentation result, with the vertices corresponding to the background having a value of 0 and those representing the object having a value of 1. Fig. 1 shows a flowchart of the algorithm, with the two main subroutines of the algorithm displayed in the two boxes.
Considering , we can see that , since the former can be obtained from the latter by setting the first two angles in (3) to zero. Therefore, the approximation can only improve with increasing .
3.3 Graph Cut Methods
For max-flow min-cut , the image is represented as a graph where denotes the set of vertices and the undirected edges. Each edge is a tuple , where and denote the vertices that the edge connects and is the weight of the edge. Equivalently, we will make use of the notation to refer to this weight. A cut is a subset of the edges , such that the terminal vertices and are in two disjoint subsets. After having constructed the graph, the minimum cut is taken, which corresponds to the cut that severs the minimal weight edges: .
To convert the image to its graph representation, each pixel in the image is first represented as a vertex in the graph. These vertices will be denoted . We consider only the 4-neighbourhood edges for each pixel, and denote these edges as “links”. The source and sink vertices, also termed the terminal vertices, are also defined, and these are vertices that represent the background and object respectively. We form edges between all pixel vertices and each terminal vertex, and denote these as “links”.
The weights for an link are given by a similarity function in terms of the pixel intensities of vertices : . The weights for the links are more complex. If the pixel in question has been chosen by the user to belong either to the foreground or background, the weights are made large so it is unlikely to be cut. For the other links between pixel and source , the weights are defined to be , where is the set of known pixel intensities labelled “object”, and the links between sink and pixel are defined similarly. Here is a scalar giving the relative importance of the links compared to the
links. In this project, we will obtain these probability distributions from prior knowledge.
On the other hand, the normalized cuts technique  performs a cut on the graph consisting only of the vertices representing the pixels. That is, it only considers the links mentioned previously. However, the result of a simple mincut tends to favor small clusters . To counteract this, normalization terms are added in the objective function, thus penalizing the presence of small clusters. The final objective function that is minimized, is then expressed as follows:
where for all (the sum of all the edge weights for the vertices in ), and is similarly defined.
4 Solving Graph Cuts with QAOA
The max-flow min-cut problem involves the hard constraints that the cut must have the source in and sink in . To impose these constraints in QAOA, the driver Hamiltonian can be tweaked [29, 30]. Therefore, the operator is applied on each qubit, apart from those that represent the terminal vertices. In addition, the sink qubit is initialized as and the source qubit as . This ensures that the sink and source qubits remain in these states throughout the evolution. The other qubits all start in the equal superposition state of . The cost Hamiltonian is that of the weighted maxcut, as given by
where is the identity over all the qubits and the notation sums over the vertices that are connected by an edge. To convert the maxcut to the mincut problem, it suffices to make the original edge weights negative.
For the normalized cuts problem, the cost Hamiltonian is turned into the following:
where and are the subsets of the vertices labelled “object” and “background” in the bitstring . Written in the diagonal form, the normalizing terms in the second bracket are calculated for each bitstring and multiplied by the existing terms formed from the standard mincut formulation in the first bracket. The driver Hamiltonian is still the operator applied on all the qubits, with the initial state of .
We make use of two methods to implement QAOA. First, we use the Rigetti’s built-in method for the algorithm. This is accessible from the package grove. The implementation makes use of the Quantum Virtual Machine (QVM) , which is a quantum simulator. It compiles the unitary gates into elementary gates that can be implemented by Rigetti’s quantum devices. We perform the optimization with a Bayesian optimizer, which evaluates the objective function according to its probabilistic belief of the function. This follows the approach of .
Secondly, we implement it using the package tensorflow. We used this framework to leverage the GPU parallelization built into the package. It also allows us to make use of the built-in gradient-based optimizers, such as AdamOptimizer. This implementation is particularly useful to simulate the normalized cuts method, with which Rigetti’s QVM had difficulties. However, with this approach, we could not simulate as many qubits since the GPU provided encountered memory issues. A subtlety is that this implementation outputs the wavefunction, and the most common bitstring is then taken to be the computational basis state with the largest contribution. The QVM implementation, however, samples from this distribution, giving a more similar result to that of a realistic quantum computer.
A contentious topic is the evaluation of the gradient for the objective function, which justifies the use of the gradient-based optimizer. The works [32, 33] give methods to evaluate the gradient, although it is not fully clear how practical it is to implement these on near-term devices.
To make the simulation more realistic, we also incorporated noise for the Rigetti QVM implementation of the case. This applies a or gate after each existing gate with a probability of 0.05 each. It is useful to look at these since any complex matrix, and therefore any error can be decomposed into these Pauli operators : for .
5 Creation of datasets
For the implementation of image segmentation, each qubit represents a pixel of the image. However, classically simulating qubits involves matrices with entries. This difficulty is in part what makes quantum computation powerful. However, for the purposes of this paper, this makes it computationally intensive to segment images of even 16 pixels. Therefore, we needed to work with small-scale images, such as and synthetic images, and croppings of larger medical images.
5.1 Bars and Stripes
The synthetic dataset that is used is called Bars and Stripes. This is created by taking binary data of possible combinations of bars and stripes that stretch over the entire image. For the dataset, there are in total 12 images. We then added a uniform noise between 0.0 up to a maximum of 0.2. The dataset is also used, which contains 28 images. As the images are essentially binary, the terminal probability distributions are such that
5.2 Medical Images
The medical images are taken from a coronary angiogram. The image of the artery that we attempted to segment is shown in Fig. 2. The midpoints of the artery were found using shortest path algorithms. Then, croppings of the image were made according to the center line of the artery. By segmenting the croppings and combining these results, the segmentation of the entire artery could be reconstructed. The cropping consists of splitting it vertically along the midpoint into two sides. The croppings were then taken on each side. The segmentation was benchmarked against the results found using classical deep learning, which were performed on the entire artery, thus giving the algorithm more context.
We determined the terminal weights by using the ground truth and the image data from parts of the same artery that were not used for the quantum segmentation task. For the pixels in the object, the intensity values are then binned into a histogram with 10 bins, each with a width of 0.1. This is normalized to turn it into the probability distribution . In this case, the posterior distribution is used for the terminal weights, since this gave a better empirical performance. The latter can be obtained from the former through Bayes’ rule, for which the assumption was made that . The same procedure is followed for the pixels in the background. The terminal probability distributions can be seen in Fig. 3.
6.1 Bars and Stripes
In Fig. 4, the resulting graphs generated from an example from the dataset can be seen for the two graph cut methods. To show the contribution of the correct bitstring in the overall final output state, Fig. 5 shows the probabilities of all the bitstrings in the max-flow min-cut implementation. This shows a peak at the correct bitstring, as well as the vanishing probabilities of the other bitstrings. Note that the last two digits of the correct bitstring are distinct, accounting for the sink and source vertices. Fig. 6 shows the same histogram for the normalized cuts method. Due to the absence of the terminal vertices, the statistics become fully symmetric, as the method can only find the partitions but cannot assign each partition with the correct label of “object” or “background”.
The results for the different datasets are shown in Table 1. As the optimization results can change each time, we perform an average over multiple runs over all images to calculate the final Dice coefficient.
For the max-flow min-cut implementation with a Bayesian optimizer, we were able to achieve the same performance as the classical one for all values of steps . It is interesting to note that even just one step with QAOA can achieve a perfect result. Note that this does not mean that the QAOA final state has a perfect overlap with the ground state. The noisy implementation with the probabilistic application of Pauli operators gave a Dice average of 0.72. The dataset was again successful, with a Dice average of 1.0.
Optimizing with the gradient-based Adam optimizer was expected to give better results. However, it actually fared worse. For one step, a Dice mean of only 0.80 was reached. The results for two and three steps were better, yielding 0.99, which is only marginally worse than the Bayesian optimizer.
For the case of the normalized cut, the algorithm could not distinguish between images where there is a stripe or bar in the middle. This was the case for the classical as well as the quantum algorithm. Instead, the segmentation tends to favor stripes to the left or right, as shown in Fig. 7
. This could possibly be resolved by subdividing the graph further to search for three partitions instead. Also note that the performance of the algorithm seems to have degraded with an increasing number of steps, going from 0.94 to 0.92 and then 0.91, although this is inconclusive due to the large standard deviation. This could be a reflection that the optimization task has increased in difficulty.
|*||max noisy QAOA||0.72||0.15||Bayes|
|norm cut classical||0.97||0.09||None|
|norm cut classical||0.86||0.19||None|
|norm cut QAOA||0.94||0.08||Adam|
|norm cut QAOA||0.92||0.1||Adam|
|norm cut QAOA||0.91||0.1||Adam|
6.2 Medical Images
For the medical images, both normalized cuts and max-flow min-cut are performed with the Adam optimizer. For both implementations, the results were averaged over three runs. An example cropped image that was segmented is shown in Fig. 8. The classical, as well as the quantum segmentation results are shown in the same figure. Note that the classical segmentation took the entire artery into account, and therefore has more context. The underlying graphs are plotted in Fig. 9 for the two graph cut methods. This shows that the problem has indeed increased in difficulty compared to the synthetic dataset, owing to the difficulty in identifying clusters within the graph.
The resulting segmentation of the entire artery is shown in Fig. 10 for normalized cuts. For both implementations, the enlarged segmented image is compared with the classical segmentation result in Fig. 11. The Dice coefficient average was 0.87 for normalized cuts, with a standard deviation of 0.09. For max-flow min-cut, the average was 0.86, with a standard deviation of 0.05. A curious feature was that even for the max-flow min-cut implementation, the object and background were sometimes confused. To tackle this ambiguity between the object and background, the fact that the right-most (left-most) pixels for the left (right) hand side croppings belonged to the artery was used.
The segmentation performed with the proposed quantum approach gave encouraging results on artificial and medical data. The Bayesian optimizer has superior performance to the Adam optimizer for the synthetic images. Possible future work includes assessing whether this is due to the nature of the objective function landscape, and whether this is the case for other datasets. The Bayesian optimizer, however, scales less well with more parameters, requiring ever more iterations to find a solution close to the global minimum. On the other hand, easily obtaining the gradient for the Adam optimizer in this setting is an open research question.
The max-flow min-cut approach, in general, gave better results than the normalized cuts approach. This was expected as the former makes use of two extra qubits. The probability distribution of the output state given by normalized cuts has in fact two peaks, corresponding to the partitions with the background and foreground labelled interchangeably. In addition, there are a few synthetic images that it cannot segment successfully.
Furthermore, one step with QAOA is sufficient on the proposed data, to achieve reliable segmentation results for both the synthetic and medical data. This is encouraging, since fewer steps with QAOA requires fewer gates, and will therefore avoid the increased noise introduced by additional gates.
An open and active area of research in the quantum computing community is analyzing the run-time of heuristic quantum algorithms and evaluating their scalability on larger quantum hardware. This is challenging as modelling noise is non-trivial and simulating large quantum computers with classical computers is not computationally tractable. In the context of this paper it would serve to compare its performance with classical problems. Although QAOA was originally developed for NP-hard problems, the max-flow min-cut problem is solvable in polynomial time[34, 35] classically. However, the normalized cuts problem is in general NP-complete . Although the quantum approach only offers an approximate solution, it has turned the problem into one of optimizing two parameters for = 1. As the classical algorithm for normalized cuts also looks at approximate solutions, future work can attempt to identify cases where QAOA can outperform the classical algorithm in the quality of the segmentation.
The size of image that can be segmented is restricted by the size of quantum computers available today. However, the announcement of larger and more powerful quantum chips from hardware manufacturers such as Google, IBM, Intel and Rigetti is encouraging and will lead to more practical and powerful computer vision algorithms. Such machines will allow better validation of image segmentation on large images and evaluation of the performance of QAOA.
This paper proposes the use of quantum computing for image segmentation, revisiting graph cut algorithms and mapping these to a quantum algorithm that is well suited to noisy near-term quantum devices. The approach is demonstrated on small artificial and medical datasets, where the data size is constrained only by the size of currently available quantum hardware. This paper takes a step towards the practical use of quantum computing in computer vision. As larger scale quantum computers become available, this nascent research topic is expected to grow and lead to significant change in algorithm development.
This work was supported by the Engineering and Physical Sciences Research Council [grant number 868 EP/L015242/1]. Concepts and information presented are based on research and are not commercially available. Due to regulatory reasons, the future availability cannot be guaranteed.
-  J. Canny. A computational approach to edge detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, PAMI-8(6):679–698, Nov 1986.
-  Berthold K.P. Horn and Brian G. Schunck. Determining optical flow. Artificial Intelligence, 17(1):185 – 203, 1981.
-  G. Klein and D. Murray. Parallel tracking and mapping for small ar workspaces. In 2007 6th IEEE and ACM International Symposium on Mixed and Augmented Reality, pages 225–234, Nov 2007.
-  Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Proceedings of the 25th International Conference on Neural Information Processing Systems - Volume 1, NIPS’12, pages 1097–1105, USA, 2012. Curran Associates Inc.
-  Hassan N. Khan, David A. Hounshell, and Erica R. H. Fuchs. Science and research policy at the end of Moore’s law. Nature Electronics, 1(1):14–21, jan 2018.
-  Catherine D Schuman, Thomas E Potok, Robert M Patton, J Douglas Birdwell, Mark E Dean, Garrett S Rose, and James S Plank. A Survey of Neuromorphic Computing and Neural Networks in Hardware. Technical report. arXiv:1705.06963v1.
-  K. Preston. Coherent Optical Computers. 1972.
-  Ehud Lamm and Ron Unger. Biological Computation. Chapman & Hall/CRC, 1st edition, 2011.
-  Mark J. Schnitzer. Biological computation: Amazing algorithms. Nature, 416(6882):683–683, apr 2002.
-  Richard P. Feynman. Simulating physics with computers. International Journal of Theoretical Physics, 21(6):467–488, Jun 1982.
-  M L Nielsen and I L Chuang. Quantum Computation and Quantum Information. 2000.
-  P.W. Shor. Algorithms for quantum computation: discrete logarithms and factoring. In Proceedings 35th Annual Symposium on Foundations of Computer Science, pages 124–134. IEEE Comput. Soc. Press.
Lov K. Grover.
A fast quantum mechanical algorithm for database search.
Proceedings of the Twenty-eighth Annual ACM Symposium on Theory of Computing, STOC ’96, pages 212–219, New York, NY, USA, 1996. ACM.
-  Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. A Quantum Approximate Optimization Algorithm. 2014. arXiv:1411.4028v1.
-  Edward Farhi, Jeffrey Goldstone, Sam Gutmann, and Hartmut Neven. Quantum Algorithms for Fixed Qubit Architectures. 2017. arXiv:1703.06199.
-  Hartmut Neven, Geordie Rose, and William G Macready. Image recognition with an adiabatic quantum computer I. Mapping to quadratic unconstrained binary optimization. Technical report, 2008. arXiv:0804.4457v1.
-  Hartmut Neven, Vasil S. Denchev, Geordie Rose, and William G. Macready. Training a Binary Classifier with the Quantum Adiabatic Algorithm. nov 2008. arXiv:0811.0416.
-  Hartmut Neven, Vasil S Denchev, Marshall Drew-Brook, Jiayong Zhang, William G Macready, and Geordie Rose. NIPS 2009 Demonstration: Binary Classification using Hardware Implementation of Quantum Annealing. Technical report, 2009.
-  Edward Grant, Marcello Benedetti, Shuxiang Cao, Andrew Hallam, Joshua Lockhart, Vid Stojevic, Andrew G Green, and Simone Severini. Hierarchical quantum classifiers. Technical report, 2018. arXiv:1804.03680v1.
-  Çaǧlar Aytekin, Serkan Kiranyaz, and Moncef Gabbouj. Quantum mechanics in computer vision: Automatic object extraction. In 2013 IEEE International Conference on Image Processing, ICIP 2013 - Proceedings, pages 2489–2493. IEEE, sep 2013.
-  Suzhen Yuan, Xia Mao, Lijiang Chen, and Yuli Xue. Quantum digital image processing algorithms based on quantum measurement. Optik - International Journal for Light and Electron Optics, 124(23):6386–6390, dec 2013.
-  Xiaowei Fu, Mingyue Ding, Yangguang Sun, and Shaobin Chen. A new quantum edge detection algorithm for medical images. volume 7497, page 749724. International Society for Optics and Photonics, oct 2009.
-  Yi Zhang, Kai Lu, and Ying Hui Gao. QSobel: A novel quantum image edge extraction algorithm. Science China Information Sciences, 58(1):1–13, 2014.
-  Zhihui Wang, Stuart Hadfield, Zhang Jiang, and Eleanor G Rieffel. The Quantum Approximation Optimization Algorithm for MaxCut: A Fermionic View. 2017. arXiv:1706.02998.
-  J S Otterbach, R Manenti, N Alidoust, A Bestwick, M Block, B Bloom, S Caldwell, N Didier, E Schuyler Fried, S Hong, P Karalekas, C B Osborn, A Papageorge, E C Peterson, G Prawiroatmodjo, N Rubin, Colm A Ryan, D Scarabelli, M Scheer, E A Sete, P Sivarajah, Robert S Smith, A Staley, N Tezak, W J Zeng, A Hudson, Blake R Johnson, M Reagor, M. P. da Silva, and C Rigetti. Unsupervised Machine Learning on a Hybrid Quantum Computer. 2017. arXiv:1712.05771.
-  Yuri Y Boykov and Marie-Pierre Jolly. Interactive Graph Cuts for Optimal Boundary & Region Segmentation of Objects in N-D Images. Proceedings Eighth IEEE International Conference on Computer Vision. ICCV 2001, I:105, 2001.
-  Jianbo Shi and Jitendra Malik. Normalized cuts and image segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(8):888–905, 2000. arXiv:cs/0703101v1.
-  Wu Zhenyu and Richard M. Leahy. Graph theoretic approach to segmentation of mr images. In Proc.SPIE, volume 1450, 1991.
-  Stuart Hadfield, Zhihui Wang, Bryan O’Gorman, Eleanor G Rieffel, Davide Venturelli, and Rupak Biswas. From the Quantum Approximate Optimization Algorithm to a Quantum Alternating Operator Ansatz. 2017. arXiv:1709.03489.
-  Tomas Babej, Mark Fingerhuth, and Christopher Ing. A quantum alternating operator ansatz with hard and soft constraints for lattice protein folding. 2018.
-  Robert S Smith, Michael J Curtis, and William J Zeng. A Practical Quantum Instruction Set Architecture. 2016. arXiv:1608.03355.
-  Kosuke Mitarai, Makoto Negoro, Masahiro Kitagawa, and Keisuke Fujii. Quantum Circuit Learning. 2018. arXiv:1803.00745.
-  Jun Li, Xiaodong Yang, Xinhua Peng, and Chang Pu Sun. Hybrid Quantum-Classical Approach to Quantum Optimal Control. Physical Review Letters, 118(15), 2017.
-  P. Elias, A. Feinstein, and C. E. Shannon. A Note on the Maximum Flow Through a Network. IRE Transactions on Information Theory, 2(4):117–119, dec 1956.
-  L. R. Ford and D. R. Fulkerson. Maximal flow through a network. Canadian Journal of Mathematics, 8(1):399–404, jan 2018.
-  Dorothea Wagner and Frank Wagner. Between min cut and graph bisection. In Mathematical Foundations of Computer Science 1993, pages 744–750, Berlin, Heidelberg, 1993. Springer Berlin Heidelberg.