arX

iv:1

811.

0172

6v3

[qu

ant-

ph]

7 O

ct 2

020

Quantum Circuit Design Methodology for Multiple Linear Regression∗

Sanchayan Dutta1,† Adrien Suau2,‡ Sagnik Dutta3,§ Suvadeep Roy3,¶

Bikash K. Behera3,4,∗∗ and Prasanta K. Panigrahi3††1Department of Electronics and Telecommunication Engineering,

Jadavpur University, Kolkata 700032, West Bengal, India2CERFACS, 42 Avenue Gaspard Coriolis, 31100 Toulouse, France

3Department of Physical Sciences, Indian Institute of Science Educationand Research Kolkata, Mohanpur 741246, West Bengal, India and

4 Bikash’s Quantum (OPC) Private Limited, Balindi, Mohanpur 741246, Nadia, West Bengal, India

Abstract

Multiple linear regression assumes an imperative role in supervised machine learning. In 2009,Harrow et al. [Phys. Rev. Lett. 103, 150502 (2009)] showed that their HHL algorithm can be usedto sample the solution of a linear system Ax = b exponentially faster than any existing classicalalgorithm, with some manageable caveats. The entire field of quantum machine learning gainedconsiderable traction after the discovery of this celebrated algorithm. However, effective practicalapplications and experimental implementations of HHL are still sparse in the literature. Here, wedemonstrate a potential practical utility of HHL, in the context of regression analysis, using theremarkable fact that there exists a natural reduction of any multiple linear regression problem toan equivalent linear systems problem. We put forward a 7-qubit quantum circuit design, motivatedfrom an earlier work by Cao et al. [Mol. Phys. 110, 1675 (2012)], to solve a 3-variable regressionproblem, using only elementary quantum gates. We also implement the Group Leaders OptimizationAlgorithm (GLOA) [Mol. Phys. 109 (5), 761 (2011)] and elaborate on the advantages of using suchstochastic algorithms in creating low-cost circuit approximations for the Hamiltonian simulation.We believe that this application of GLOA and similar stochastic algorithms in circuit approximationwill boost time- and cost-efficient circuit designing for various quantum machine learning protocols.Further, we discuss our Qiskit simulation and explore certain generalizations to the circuit design.

I. Introduction

Quantum algorithms running on quantum computersaim at quickly and efficiently solving several importantcomputational problems faster than classical algorithmsrunning on classical computers [1–11]. One key wayin which quantum algorithms differ from classicalalgorithms is that they utilize quantum mechanicalphenomena such as superposition and entanglement,that allows us to work in exponentially large Hilbertspaces with only polynomial overheads. This in turn,in some cases, allows for exponential speed-ups in termsof algorithmic complexity [1].

In today’s world, machine learning is primarily concernedwith the development of low-error models in orderto make accurate predictions possible by learning andinferring from training data [12, 13]. It borrows heavilyfrom the field of statistics in which linear regressionis one of the flagship tools. The theory of multiplelinear regression or more generally multivariate linearregression was largely developed in the field of statistics

∗ These authors contributed equally to the work:† sanchayan98@gmail.com‡ adrien.suau@cerfacs.fr§ sd15ms136@iiserkol.ac.com¶ sr15ms116@iiserkol.ac.com;These authors supervised the project:

∗∗ bikash@bikashsquantum.com†† pprasanta@iiserkol.ac.in

in the pre-computer era. It is one of the most wellunderstood, versatile, and straightforward techniquesin any statistician’s toolbox. It is also an importantand practical supervised learning algorithm. Supervisedlearning is where one has some labeled input datasamples xi,yiNi=1 (where xi’s are the feature vectorsand yi’s are the corresponding labels) and then basedon some criteria (which might depend on the context)chooses a mapping from the input set X to the outputset Y. And that mapping can help to predict theprobable output corresponding to an input lying outsideof the training data sets. Multiple linear regression issimilar in the sense that given some training samplesone identifies a closely fitting hyperplane dependingon the specific choice of a loss function (the mostcommon one being a quadratic loss function based onthe “least squares” method). Interestingly, any multipleregression problem can be converted into an equivalentsystem of linear equations problem or more specifically,a Quantum Linear Systems Problem (QLSP) problem[14]. The process has been outlined using an example inSection III.

Suppose that we are given a system of N linear equationswith N unknowns, which can be expressed as Ax = b.Now, what we are interested in, is: given a matrix A ∈CN×N with a vector b ∈ CN , find the solution x ∈ CN

satisfying Ax = b (which is A−1b if A is invertible), orelse return a flag if no solution exists. This is knownas the Linear Systems Problem (LSP). However, we willconsider only a special case of this general problem, in

2

form of the Quantum Linear Systems Problem (QLSP)[14, 15].The quantum version of the LSP problem, the QLSP, canbe expressed as:Let A be a N × N Hermitian matrix with a spectralnorm bounded by unity and a known condition numberκ. The quantum state on ⌈logN⌉ qubits |b〉 can be givenby

|b〉 :=∑

i bi |i〉||∑i bi |i〉 ||

(1)

and |x〉 by

|x〉 :=∑

i xi |i〉||∑

i xi |i〉 ||(2)

where bi, xi are respectively the ith component of vectors band x. Given the matrix A (whose elements are accessedby an oracle) and the state |b〉, an output state |x〉 issuch that || |x〉 − |x〉 ||2 ≤ ǫ, with some probability Ω(1)(practically at least 1

2) along with a binary flag indicating

‘success’ or ‘failure’ [14].The restrictions on Hermiticity and spectral norm, canbe relaxed by noting that, even for a non-HermitianmatrixA, the corresponding

[0 A

†

A 0

]matrix is Hermitian.

This implies that we can instead solve the linear systemgiven by

[0 A

†

A 0

]y = [ b0 ], which has the unique solution

y = [ 0x] when A is invertible [4]. Also, any non-singular

matrix can be scaled appropriately to adhere to the givenconditions on the eigenspectrum. Note that the casewhen A is non-invertible, has already been excluded bythe fact that a known finite condition number exists forthe matrix A.In 2009, A. W. Harrow, A. Hassidim, and S. Lloyd [4]put forward a quantum algorithm (popularly known asthe “HHL algorithm”) to obtain information about thesolution x of certain classes of linear systems Ax = b.As we know, algorithms for finding the solutions tolinear systems of equations play an important role inengineering, physics, chemistry, computer science, andeconomics apart from other areas. The HHL algorithmis highly celebrated in the world of quantum algorithmsand quantum machine learning, but there is still adistinct lack of literature demonstrating practical uses ofthe algorithm and their experimental implementations.Experimentally implementing the HHL algorithm forsolving an arbitrary system of linear equations to asatisfactory degree of accuracy, remains an infeasibletask even today, due to several physical and theoreticalrestrictions imposed by the algorithm and the currentlyaccessible hardware. Our fundamental aim in this paperis to put forth a neat technique to demonstrate howHHL can be used for one of the most useful toolsin statistical modeling — multiple regression analysis.We show that there is a canonical reduction of anymultiple linear regression problem into a quantum linear

systems problem (QLSP) that is thereafter amenableto a solution using HHL. It turns out that, afterslight modifications and classical pre-processing, thecircuit used for HHL can be used for multiple linearregression as well. Here we should point out, inScott Aaronson’s words [16], that the HHL algorithmis mostly a template for other quantum algorithmsand it has some caveats that must be kept in mindduring the circuit design and physical implementationstep, to preserve the exponential speedup offered bythe algorithm. Nonetheless, these issues are not alwaysdetrimental and can often be overcome by appropriatelypreparing and justifying the circuit design methodologyfor specific purposes, as we will do here. There is anotherbrief discussion related to these issues in the Conclusionssection of the paper.

In Section IV, we present an application (in the context ofmultiple regression) of a modified version of the earliercircuit design by Cao et al. [19] which was meant forimplementing the HHL algorithm for a 4×4 linear systemon real quantum computers. This circuit requires only 7qubits and it should be simple enough to experimentallyverify it if one gets access to a quantum processor havinglogic gates with sufficiently low error rates. Previously,Pan et al. demonstrated HHL on a 4-qubit NMRquantum computer [18], so we believe that it will beeasily possible to experimentally implement the circuitwe discuss, given the rapid rise in the number of qubitsin quantum computer chips, in the past few years.

We also note that although HHL solves the QLSP for allmatrices A or

[0 A

†

A 0

], it can be efficiently implemented

only when they are sparse and well-conditioned (thesparsity condition may be slightly relaxed) [14]. In thiscontext, ‘efficient’ means ‘at most polylogarithmic insystem size’. AN×N matrix is called s-sparse if it has atmost s non-zero entries in any row or column. We call itsimply sparse if it has at most poly(logN) entries per row[15]. We generally call a matrix well-conditioned when itssingular values lie between the reciprocal of its conditionnumber ( 1κ) and 1 [4]. Condition number κ of a matrixis the ratio of largest to smallest singular value and isundefined when the smallest singular value of A is 0.For Hermitian matrices the eigenvalue magnitudes equalthe magnitudes of the respective singular values.

At this point, it is important to reiterate that unlikethe output A−1b of a classical linear system solver,the output copy of |x〉 does not provide access to thecoordinates ofA−1b. Nevertheless, it allows for samplingfrom the solution vectors like 〈x|M |x〉, where M isa quantum-mechanical operator. This is one maindifference between solutions of the LSP and solutions ofthe QLSP. We should also keep in mind that reading outthe elements of |x〉 in itself takes O(N) time. Thus, asolution to QLSP might be useful only in applicationswhere just samples from the vector |x〉 are needed[4, 14, 15].

The best existing classical matrix inversion algorithminvolves the Gaussian elimination technique which takes

3

O(N3) time. For s-sparse and positive semi-definiteA, the Conjugate Gradient algorithm [20] can be usedto find the solution vector x in O(Nsκ log(1/ǫ)) timeby minimizing the quadratic error function |Ax− b|2,where s is the matrix sparsity, κ is the condition numberand ǫ is the desired precision parameter. On the otherhand, the HHL algorithm scales as O(log(N)s2κ2/ǫ),and is exponentially faster in N but polynomiallyslower in s and κ. In 2010, Andris Ambainis furtherimproved the runtime of HHL to O(κ log3 κ logN/ǫ)[21]. The exponentially worse slowdown in ǫ wasalso eliminated [14] by Childs et al. in 2017 and itgot improved to O(sκpolylog(sκ/ǫ)) [15]. Since HHLhas logarithmic scaling only for sparse or low-rankmatrices, in 2018, Wossnig et al. extended the HHLalgorithm with quantum singular value estimation andprovided a quantum linear system algorithm for densematrices which achieves a polynomial improvement intime complexity, that is, O(

√Npolylog(N)κ2/ǫ) [22]

(HHL retains its logarithmic scaling only for sparseor low-rank matrices). Furthermore, an exponentialimprovement is achievable with this algorithm if the rankof A is polylogarithmic in the matrix dimension.Last but not least, we note that it is assumed thatthe state |b〉 can be efficiently constructed i.e., preparedin ‘polylogarithmic time’. In reality, however, efficientpreparation of arbitrary quantum states is hard and issubject to several constraints.

II. The Harrow Hassidim Lloyd Algorithm

The HHL algorithm consists of three major steps whichwe will briefly discuss one by one. Initially, we beginwith a Hermitian matrix A and an input state |b〉corresponding to our specific system of linear equations.The assumption that A is Hermitian may be droppedwithout loss of generality since we can instead solve thelinear system of equations given by

[0 A

†

A 0

]y = [ b0 ] which

has the unique solution y = [ 0x] when A is invertible.

This transformation does not alter the condition number(ratio of the magnitudes of the largest and smallesteigenvalues) of A [4, 14]. However, in the case ouroriginal matrix A is not Hermitian, the transformedsystem with the new matrix

[0 A

†

A 0

]needs oracle access

to the non-zero entries of the rows and columns of A

[14]. Since A is assumed to be Hermitian, it followsthat eiAt is unitary. Here iAt and −iAt commute andhence eiAte−iAt = eiAt−iAt = e0 = I. Moreover, eiAt

shares all its eigenvectors with A, while its eigenvaluesare eiλj t if the eigenvalues of A are taken to be λj .Suppose that |uj〉 are the eigenvectors ofA and λj are thecorresponding eigenvalues. We recall that we assumed all

1 The HHL algorithm schematic (Fig. I) was generated using theTikZ code provided by Dr. Niel de Beaudrap (Department ofComputer Science, Oxford University). It was inspired by figure5 of the Dervovic et al. paper [15].

the eigenvalues to be of magnitude less than 1 (spectralnorm is bounded by unity). As the eigenvalues λj are ofthe form 0.a1a1a3 · · · in binary [1, p. 222], we will use|λj〉 to refer to |a1a2a3 · · ·〉. We know from the spectraltheorem that every Hermitian matrix has an orthonormalbasis of eigenvectors. So, in this context, A can bere-written as

∑j λj |uj〉 〈uj | (via eigendecomposition of

A) and |b〉 as∑

j βj |u〉j .

A. Phase Estimation

The quantum phase estimation algorithm performs the

mapping(|0〉⊗n

)C|u〉I |0〉S 7→ |ϕ〉C |u〉I |0〉S where |u〉

is an eigenvector of a unitary operator U with anunknown eigenvalue ei2πϕ [1]. ϕ is a t-bit approximationof ϕ, where t is the number of qubits in the clockregister. The superscripts on the kets indicate thenames of the registers which store the correspondingstates. In the HHL algorithm the input register beginswith a superposition of eigenvectors instead i.e., |b〉 =∑

j βj |uj〉 instead of a specific eigenvector |u〉, and for

us the unitary operator is eiAt. So the phase estimationcircuit performs the mapping

(|0〉⊗n

)C|b〉I 7→

N∑

j=1

βj |uj〉I∣∣∣∣∣λjt02π

⟩C

where λj ’s are the binary representations of theeigenvalues of A to a tolerated precision. To be moreexplicit, here λj is represented as b1b2b3 · · · bt (t beingnumber of qubits in the clock register) if the actual binaryequivalent of λj is of the form λ = 0.b1b2b3 · · · . Toavoid the factor of 2π in the denominator, the ‘evolutiontime’ t0 is generally chosen to be 2π. However, t0 mayalso be used to ‘normalize’ A (by re-scaling t0) in casethe spectral norm of A exceeds 12. Additionally, animportant factor in the performance of the algorithmis the condition number κ. As κ grows, A tendsmore and more towards a non-invertible matrix, and thesolutions become less and less stable [4]. Matrices withlarge condition numbers are said to be ‘ill-conditioned’.The HHL algorithm generally assumes that the singularvalues of A lie between 1/κ and 1, which ensures thatthe matrices we have to deal with are ‘well-conditioned’.Nonetheless, there are methods to tackle ill-conditionedmatrices and those have been thoroughly discussed in thepaper by Lloyd et al. [4]. It is worth mentioning thatin this step the ‘clock register’-controlled Hamiltonian

simulation gate U can be expressed as∑T−1

k=0 |τ〉 〈τ |C ⊗

2 Ideally, we should know both the upper bound and the lowerbound of the eigenvalues, for effective re-scaling. Furthermore, toget accurate estimates, we should attempt to spread the possiblevalues of λt over the whole 2π range.

4

FIG. 1. HHL Algorithm Schematic 1

eiAτt0/T , where T = 2t and evolution time t0 = O(κ/ǫ).Interestingly choosing t0 = O(κ/ǫ) can at worse cause anerror of magnitude ǫ in the final state [4].

B. R(λ−1) rotation

A ‘clock register’ controlled σy-rotation of the ‘ancilla’qubit produces a normalized state of the form

N∑

j=1

βj |uj〉I∣∣∣λj

⟩C(√

1− C2

λ2j

|0〉+ C

λj

|1〉)S

These rotations, conditioned on respective λj , canbe achieved by the application of the exp(−iθσy) =[cos θ − sin θsin θ cos θ

]operators where θ = cos−1

(C

λj

). C

is a scaling factor to prevent the controlled rotation frombeing unphysical [15]. That is, practically C < λmin

is a safe choice, which may be more formally stated asC = O(1/κ) [4].

C. Uncomputation

In the final step, the inverse quantum phase estimationalgorithm sets back the clock register to (|0〉⊗n

)C andleaves the remaining state as

N∑

j=1

βj |uj〉I(√

1− C2

λ2j

|0〉+ C

λj

|1〉)S

Postselecting on the ancilla |1〉S gives the final state

C∑N

j=1(βj

λj) |uj〉I [15]. The inverse of the Hermitian

matrix A can be written as∑

j1λj

|uj〉 〈uj|, and hence

A−1|b〉 matches∑N

j=1

βj

λj

|uj〉I . This outcome state, in

the standard basis, is component-wise proportional tothe exact solution x of the system Ax = b [19].

III. Linear Regression Utilizing HHL

Linear regression models a linear relationship betweena scalar ‘response’ variable and one or more ‘feature’variables. Given a n-unit data set yi, xi1, · · · , xipni=1,a linear regression model assumes that the relationshipbetween the dependent variable y and a set of p attributesi.e., x = x1, · · · , xp is linear [12]. Essentially, the modeltakes the form

yi = β0 + β1x1 + · · ·+ βpxip + ǫi = xTi βββ + ǫi

where ǫi is the noise or error term. Here i ranges from 1to n. xT

i denotes the transpose of the column matrix xi.And xT

i βββ is the inner product between vectors xi and βββ.These n equations may be more compactly representedin the matrix notation, as y = Xβββ + ǫǫǫ. Now, we willconsider a simple example with 3 feature variables and abias β0. Say our data sets are − 1

8+ 1

8√2,−

√2, 1√

2,− 1

2,

38− 3

8√2,−

√2,− 1√

2, 12, − 1

8− 1

8√2,√2,− 1√

2,− 1

2 and

38+ 3

8√2,√2, 1√

2, 12. Plugging in these data sets we get

the linear system:

β0 −√2β1 +

1√2β2 −

1

2β3 = −1

8+

1

8√2

(3)

β0 −√2β1 −

1√2β2 +

1

2β3 =

3

8− 3

8√2

(4)

β0 +√2β1 −

1√2β2 −

1

2β3 = −1

8− 1

8√2

(5)

β0 +√2β1 +

1√2β2 +

1

2β3 =

3

8+

3

8√2

(6)

5

To estimate βββ we will use the popular “least squares”method, which minimizes the residual sum of squares∑N

i=1(yi − xiβββi)2. If X is positive definite (and in turn

has full rank) we can obtain a unique solution for the

best fit βββ, which is (XTX)−1XTy. It can happen thatall the columns of X are not linearly independent and byextension X is not full rank. This kind of situation mightoccur if two or more of the feature variables are perfectly

correlated. Then XTX would be singular and β wouldn’tbe uniquely defined. Nevertheless, there exist techniqueslike “filtering” to resolve the non-unique representationsby reducing the redundant features. Rank deficienciesmight also occur if the number of features p exceeds thenumber of data sets N . If we estimate such models using“regularization”, then redundant columns should not beleft out. The regulation takes care of the singularities.More importantly, the final prediction might depend onwhich columns are left out [23].Equations (3)-(6) may be expressed in the matrixnotation as:

−√2 1 1√

2− 1

2

−√2 1 − 1√

2

12

−√2 −1 1√

2

12

√2 1 1√

2

12

β1

β0

β2

β3

=

− 18+ 1

8√2

38− 3

8√2

18+ 1

8√2

38+ 3

8√2

(7)

Note that unlike common convention, our representationof X does not contain a column full of 1’s correspondingthe bias term. This representation is used simply becauseof the convenient form that we obtain forXTX. The finalresult remains unaffected as long as y = Xβββ representsthe same linear system.Now

XTX =1

4

15 9 5 −3

9 15 3 −5

5 3 15 −9

−3 −5 −9 15

(8)

and

XTy =

12

12

12

12

. (9)

Thus we need to solve for βββ from XTXβββ = XTy

[12].

IV. Quantum Circuit

Having discussed the general idea behind the HHLalgorithm in Section II and its possible application in

drastically speeding up multiple regression in Section III,we now move on to the quantum circuit design meant tosolve the 4 × 4 linear system which we encountered inSection III i.e., XTXβ = XTy. For sake of conveniencewe will now denote XTX with A, β with x and XTy

with b. The circuit requires only 7 qubits, with 4 qubitsin the “clock register”, 2 qubits in the “input register”and the remaining 1 as an “ancilla” qubit. At this pointit is imperative to mention that we specifically chose theform of the regression data points in the previous Sectionsuch that A turns out to be Hermitian, has four distincteigenvalues of the form λi = 2i−1 and b has a convenientform which can be efficiently prepared by simply usingtwo Hadamard gates.

A = XTX =1

4

15 9 5 −3

9 15 3 −5

5 3 15 −9

−3 −5 −9 15

(10)

A is a Hermitian matrix with eigenvalues λ1 = 1, λ2 =2, λ3 = 4 and λ4 = 8. The corresponding eigenvectorsencoded in quantum states |uj〉 may be expressedas

|u1〉 = −|00〉 − |01〉 − |10〉+ |11〉 (11)

|u2〉 = +|00〉+ |01〉 − |10〉+ |11〉 (12)

|u3〉 = +|00〉 − |01〉+ |10〉+ |11〉 (13)

|u4〉 = −|00〉+ |01〉+ |10〉+ |11〉 (14)

Also, b =[12

12

12

12

]Tcan be written as

∑j=4

j=1 βj |uj〉where each βj =

12.

We will now trace through the quantum circuit in Fig. 2.|q0〉 and |q1〉 are the input register qubits which areinitialized to a combined quantum state

|b〉 = 1

2|00〉+ 1

2|01〉+ 1

2|10〉+ 1

2|11〉 (15)

which is basically the state-encoded format of b.This is followed by the quantum phase estimationstep which involves a Walsh-Hadamard transformon the clock register qubits |j0〉, |j1〉, |j2〉, |j3〉, a

clock register controlled unitary gates U20 , U21 , U22

and U23 where U = exp(iAt/16) and an inversequantum Fourier transform on the clock register. Asdiscussed in Section II, this step would produce thestate 1

2|0001〉C|u1〉I + 1

2|0010〉C|u2〉I + 1

2|0100〉C |u3〉I +

12|1000〉C|u4〉I , which is essentially the same as∑N

j=1 βj |uj〉I∣∣∣ λj t0

2π

⟩C, assuming t0 = 2π. Also, in this

specific example |λj〉 = |λj〉, since the 4 qubits in the

6

|s〉 = |0〉 Ry(8τ) Ry(4τ) Ry(2τ) Ry(τ)LL ❴❴❴❴❴❴❴❴

❴ ❴ ❴ ❴ ❴ ❴ ❴ ❴

|j3〉 = |0〉 H •

FT †

•

FT

• H

|j2〉 = |0〉 H • • • H

|j1〉 = |0〉 H • • • H

|j0〉 = |0〉 H • • • H

|q1〉 = |0〉 Hf1 f2 f4 f8 f−1 f−2 f−4 f−8

|q0〉 = |0〉 H

FIG. 2. Quantum circuit for solving a 4 × 4 linear system Ax = b. Here f = exp(iAt/16) and τ = π/2r . The top qubit (|s〉)is the ancilla qubit. The four qubits in the middle (|j0〉, |j1〉, |j2〉 and |j3〉) stand for the Clock register C. The two qubits atthe bottom (|q0〉 and |q1〉) form the Input register I and two Hadamard gates are applied on them to initialize the state |b〉.

clock register are sufficient to accurately and preciselyrepresent the 4 eigenvalues in binary. As far as theendianness of the combined quantum states is concernedwe must keep in mind that in our circuit |q0〉 is the mostsignificant qubit (MSQ) and |q3〉 is the least significantqubit (LSQ).

Next is the R(λ−1) rotation step. We make use of anancilla qubit |s〉 (initialized in the state |0〉), which getsphase shifted depending upon the clock register’s state.Let’s take an example clock register state |0100〉C =|0〉Cq0 ⊗ |1〉Cq1 ⊗ |0〉Cq2 ⊗ |0〉Cq3 (binary representation of theeigenvalue corresponding to |u3〉, that is 4). In thiscombined state, |q1〉 is in the state |1〉 while |q0〉, |q2〉 and|q3〉 are all the in state |0〉. This state will only trigger theRy(

2π2r) rotation gate, and none of the other phase shift

gates. Thus, we may say that the smallest eigenvaluestates in C cause the largest ancilla rotations. Usinglinearity arguments, it is clear that if the clock registerstate had instead been |b〉, as in our original example,the final state generated by this rotation step would be∑N

j=1 βj |uj〉I∣∣∣λj

⟩C((1− C2/λ2

j )1/2 |0〉+ C

λj

|1〉)S where

C = 8π/2r. For this step, an a priori knowledge ofthe eigenvalues of A was necessary to design the gates.For more general cases of eigenvalues, one may refer to[19].

Then, as elaborated in Section II, the inversephase estimation step essentially reverses the quantumphase estimation step. The state produced bythis step, conditioned on obtaining |1〉 in ancilla is8π2r

∑j=4

j=1

12

2j−1 |uj〉. Upon writing in the standard basis

and normalizing, it becomes 1√340

(−|00〉+7|01〉+11|10〉+13|11〉). This is proportional to the exact solution of the

system x = 132

[−1 7 11 13

]T.

V. Simulation

We simulated the quantum circuit in Fig. 2 usingthe Qiskit Aer QasmSimulator backend [17], whichis a noisy quantum circuit simulator backend. Oneof the main hurdles while implementing the quantumprogram was dealing with the Hamiltonian simulationstep i.e., implementing the controlled unitary U =eiAt. Taking a cue from the Cao et al. paper[19] which employed the Group Leaders OptimizationAlgorithm (GLOA) [24], we approximately decomposedthe U gate into elementary quantum gates, as shownin Fig. 3. It’s however important to keep in mindthat using GLOA to decompose the U is useful onlywhen the matrix exponential eiAt is readily available.

Let’s call the resulting approximated unitary U. Theparameters of the Rx and Rzz gates given in [19] wererefined using the scipy.optimize.minimize function [25],

to minimize the Hilbert-Schmidt norm of U − U (which

is a measure of the relative error between U and U).The scipy.optimize.minimize function makes use of thequasi-Newton algorithm of Broyden, Fletcher, Goldfarb,and Shanno (BFGS) [26] by default. Also, we noticedthat it is necessary to use a controlled-Z gate instead ofa single qubit Z gate (as in [19]).

A sample output of the Qiskit code has been shownin the text-box (V). All the results have been roundedto 4 decimal places. The ‘Error in found solution’is in essence the 2-norm of the difference betweenthe exact solution and the output solution. We haveneglected normalization and constant factors like 1

32in

the displayed solutions.

7

exp ( iAt016

)• Rx(0.981) Rzz(0.589) • Rx(1.178) • •

Z Rx(0.196)√X

†Rzz(0.379) X X Z

=

exp ( iAt08

)• Rx(1.963) Rzz(2.615) • Rx(1.178) • •

Z Rx(1.963)√X

†Rzz(1.115) X X Z

=

exp ( iAt04

)• Rx(3.927) Rzz(2.517) • Rx(2.356) • •

Z Rx(−0.785)√X

†Rzz(1.017) X X Z

=

exp ( iAt02

)• Rx(1.571) Rzz(0.750) • Rx(−1.571) • •

Z Rx(−9.014× 10−9)√X

†Rzz(−0.750) X X Z

=

FIG. 3. The Group Leaders Optimization Algorithm is employed to approximately decompose the exp(

iAt

2k

)

gates in theHamiltonian simulation step into elementary quantum gates. The decomposition is not unique. The specific gate decompositionsshown in the diagram were taken Cao et al.[19] and the angle shifts were corrected using the scipy.optimize.minimize module.

Qisk i t S imulat ion − Sample Output :( Unnormalized )

Pred ic ted s o l u t i o n :[−1 7 11 13 ]

Simulated exper iment s o l u t i o n :[−0.8425 6 .9604 10 .9980 13 .0341 ]

Error in found s o l u t i o n : 0 .1660

It is clear from the low error value that the gate

decomposition we used for U helps to approximatelyreplicate the ideal circuit involving U. Also, thedifference between the predicted and simulated results(with shots = 105) has been shown in Fig. 4.One should remember that using genetic algorithmslike GLOA for the Hamiltonian simulation step is aviable technique only when cost of computing the matrixexponential eiAt is substantially lower than the costof solving the corresponding linear system classically.A popular classical algorithm for calculating matrixexponentials is the ‘The Scaling and Squaring Algorithm’by Al-Mohy and J. Higham [28, 29, 31], whose costis O(n3), and which is generally used along with thePade approximation by Matlab [30] and SciPy [25]. Butthis algorithm is mostly used for small dense matrices.For large sparse matrices, better approaches exist. For

FIG. 4. The blue bars represent the predicted stateamplitudes for the solution vector |x〉. The red barsindicate the simulated experiment results using Qiskit AerQasmSimulator (a noisy quantum simulator backend) for thestate amplitudes. The states have not been normalized, sothat the deviation from the solution of the original linearequation system is prominent.

instance, in the Krylov space approach [32][33], anArnoldi algorithm is used whose cost is in the ballparkof O(mn), where n is the matrix size and m is thenumber of Krylov vectors which need to be computed. Ingeneral, for large sparse matrices, GLOA may be useful

8

but that decision needs to be made on a case-by-casebasis depending on the properties of the matrixA.

VI. Discussion and Conclusions

We have noticed that any multiple linear regressionproblem can be reduced to an equivalent quantum linearsystems problem (QLSP). This allows us to utilize thegeneral quantum speed-up techniques like the HHLalgorithm. However, for HHL we need low-error low-costcircuits for the Hamiltonian simulation and controlledrotation steps to get accurate results. There already existwell-defined deterministic approaches like the celebratedSolovay-Kitaev and Trotter-Suzuki algorithms [37–40]that can help to decompose the Hamiltonian simulationunitary U up to arbitrary accuracy. But in mostcases, they provide neither minimum cost nor efficientlygenerable gate sequences for engineering purposes. TheSolovay-Kitaev algorithm, which scales as O(log(1/ǫ)),takes advantage of the fact that quantum gates areelements of the unitary group U(d), which is a Lie groupand a smooth differentiable manifold, in which one can doprecise calculations regarding the geometry and distancebetween points. Similarly, the Trotter-Suzuki algorithmuses a product formula that can precisely approximatethe Hamiltonian exponential, and which exploits thestructure of commutation relations in the underlying Liealgebras. In practical engineering scenarios, however, onewould prefer a low-cost gate sequence that approximatesthe unitary just well enough, rather than a high-cost andexact or almost exact decomposition.

This is where stochastic genetic algorithms like GLOAcome into play. These are heuristic algorithms that donot have well-defined time complexities and error bounds.Given a particular matrix A, if the time taken to find acircuit approximation for the Hamiltonian evolution, is(say) polynomial-time O(nc) for some constant c, theexponential speedup disappears. This remains an issuewith GLOA because we still need to classically computethe 2n× 2n unitary matrix of the evolution we are tryingto approximate. The real advantage of GLOA shows upwhen dealing with large data sets, as the standard GLOA[19, 24] restricts the number of gates to a maximumof 20 (a detailed explanation of GLOA is available inthe supplementary material). So while the number oflinear equations and the size of the data sets can bearbitrarily large, it will only ever use a limited numberof gates for approximating the Hamiltonian simulation.This property of GLOA ensures that time taken forHamiltonian simulation remains nearly independent ofthe size of the data sets as they grow large. Our circuitdesign technique will be useful for engineering purposes,particularly when the regression analysis is to be done onextensive amounts of data. Using GLOA, it is also oftenpossible to incorporate other desired aspects of circuitdesign into the optimization, like specific choices of gatesets. The maximum size of data set on which we can usethis approach is only limited by the number of qubits

available in the quantum processors.It is noteworthy that regression analysis is widely used invarious scientific and business applications, as it enablesone to understand the relationship between variableparameters and make predictions about unknowns.Every day in the actual world, the handling of largerand larger data sets craves for faster and more efficientapproaches to such analyses. It is natural to ask whetherit might be possible to leverage quantum algorithms forthis purpose. The answer seems to be a yes, althoughthere remain several technical and engineering challenges;the dearth of sufficient experimental realizations istestimony to this. Our work on quantum multiplelinear regression, which is a first of its kind, shows apractical circuit design method that we believe will pavethe path for more viable and economic experimentalimplementations of quantum machine learning protocols,addressing problems in business analytics, machinelearning, and artificial intelligence. In particular,this work opens a new door of possibilities for time-and cost-efficient experimental realizations of variousquantum machine learning protocols, exploiting heuristicapproaches like GLOA, which will make incrementallylarge amounts of data tractable.

VII. Acknowledgements

Sanchayan Dutta would like to thank IISER Kolkata forproviding hospitality and support during the period ofthe Summer Student Research Program (2018). AdrienSuau acknowledges the support provided by CERFACS.Suvadeep Roy and Sagnik Dutta are obliged to INSPIRE,MHRD for their support. B.K.B. acknowledges thefinancial support of IISER Kolkata. The authorsacknowledge the support of the Qiskit SDK in enablingus to simulate the quantum circuits. They appreciatethe assistance received from Charles Moussa (OakRidge National Lab, Tennessee) in comprehendingthe intricacies of the GLOA algorithm. They alsoacknowledge the help received from members of theQuantum Computing Stack Exchange and the Qiskitteam in various stages of the research project.

9

References

[1] Nielsen, M.A., Chuang, I.L.: ‘Quantum Computationand Quantum Information: 10th Anniversary Edition’(Cambridge University Press, 2010).

[2] Lloyd, S.: ‘Universal Quantum Simulators’ Science, 1996,273, (5278), pp. 1073–1078.

[3] Aharonov, D., Ta-Shma, A.: ‘Adiabatic quantum stategeneration and statistical zero knowledge’, in ‘STOC ’03:Proceedings of the thirty-fifth annual ACM symposiumon Theory of Computing’ (2003), pp. 20–29.

[4] Harrow, A.W., Hassidim, A., Lloyd, S.: ‘QuantumAlgorithm for Linear Systems of Equations’ Phys. Rev.Lett., 2009, 103, (15).

[5] Hallgren, S., Hales, L.: ‘Proceedings 41st AnnualSymposium on Foundations of Computer Science’, in‘Proceedings 41st Annual Symposium on Foundations ofComputer Science’ (2000), pp. 515–525

[6] Farhi, E., Goldstone, J., Gutmann, S.: ‘A QuantumApproximate Optimization Algorithm’ arXiv 1411.4028[quant-ph], 2014.

[7] Peruzzo, A., McClean, J., Shadbolt, P., et al.: ‘Avariational eigenvalue solver on a photonic quantumprocessor’ Nat. Commun., 2014, 5, (1).

[8] Kandala, A., Mezzacapo, A., Temme, K., et al.:‘Hardware-efficient variational quantum eigensolver forsmall molecules and quantum magnets’ Nature, 2017,549, (7671), pp. 242–246.

[9] Srinivasan, K., Satyajit, S., Behera, B.K., Panigrahi,P.K.: ‘Efficient quantum algorithm for solving travellingsalesman problem: An IBM quantum experience’ arXiv1805.10928 [quant-ph], 2018.

[10] Dash, A., Sarmah, D., Behera, B.K., Panigrahi, P.K.:‘Exact search algorithm to factorize large biprimes anda triprime on IBM quantum computer’ arXiv 1805.10478[quant-ph], 2018.

[11] Maji, R., Behera, B.K., Panigrahi, P.K.: ‘Solving LinearSystems of Equations by Using the Concept of Grover’sSearch Algorithm: An IBM Quantum Experience’ arXiv1801.00778 [quant-ph], 2017.

[12] Hastie, T., Friedman, J., Tibshirani, R.: ‘The Elementsof Statistical Learning’ (Springer Series in Statistics, NewYork, USA, 2001).

[13] Biamonte, J., Wittek, P., Pancotti, N., Rebentrost,P., Wiebe, N., Lloyd, S.: ‘Quantum machine learning’Nature, 2017, 549, (7671), pp. 195–202.

[14] Childs, A.M., Kothari, R., Somma, R.D.: ‘QuantumAlgorithm for Systems of Linear Equations withExponentially Improved Dependence on Precision’ SIAMJ. Comput., 2017, 46, (6), pp. 1920–1950.

[15] Dervovic, D., Herbster, M., Mountney, P., Severini,S., Usher, N., Wossnig, L.: ‘Quantum linear systemsalgorithms: a primer’ arXiv 1802.08227 [quant-ph], 2018.

[16] Aaronson, S.: ‘Read the fine print’ Nat. Phys., 2015, 11,(4), pp. 291–293.

[17] Suau, A.: ‘Working 4x4 HHL implementation’ Zenodo,2018. (https://doi.org/10.5281/zenodo.1480660)

[18] Pan, J., Cao, Y., Yao, X., et al.: ‘Experimentalrealization of quantum algorithm for solving linearsystems of equations’ Phys. Rev. A, 2014, 89, (2).

[19] Cao, Y., Daskin, A., Frankel, S., Kais, S.: ‘Quantumcircuit design for solving linear systems of equations’ Mol.Phys., 2012, 110, (15-16), pp. 1675–1680.

[20] Hestenes, M.R., Stiefel, E.: ‘Methods of conjugategradients for solving linear systems’ J. Res. Natl. Bur.Stand., 1952, 49, (6), pp. 409–436.

[21] Ambainis, A.: ‘Variable time amplitude amplificationand a faster quantum algorithm for solving systems oflinear equations’ arXiv 1010.4458 [quant-ph], 2010.

[22] Wossnig, L., Zhao, Z., Prakash, A.: ‘Quantum LinearSystem Algorithm for Dense Matrices’ Phys. Rev. Lett.,2018, 120, (5), p. 050502.

[23] Buhlmann, P., van de Geer, S.: ‘Statistics forHigh-Dimensional Data: Methods, Theory andApplications’ (Springer Science & Business Media,2011).

[24] Daskin, A., Kais, S.: ‘Group leaders optimizationalgorithm’ Mol. Phys., 2011, 109, (5), pp. 761–772.

[25] Jones, E., Oliphant, T., Peterson, P.: ‘Scipy: Opensource scientific tools for Python’ (2001).

[26] Nocedal, J., Wright, S.J.: ‘Numerical optimization 2ndedn’ Research and Financial Engineering Springer, 2006.

[27] Daskin, A., Kais, S.: ‘Decomposition of unitary matricesfor finding quantum circuits: application to molecularHamiltonians’ J. Chem. Phys., 2011, 134, (14), p. 144112.

[28] Al-Mohy, A.H., Higham, N.J.: ‘A New Scaling andSquaring Algorithm for the Matrix Exponential’ (2010),31, pp. 970–989

[29] Higham, N.J.: ‘The Scaling and Squaring Method forthe Matrix Exponential Revisited’ SIAM J. Matrix Anal.Appl., 2005, 26, (4), pp. 1179–1193.

[30] The MathWorks Inc.: ‘Matlab Mathematics R2018b’(2018).

[31] Moler, C., Van Loan, C.: ‘Nineteen Dubious Waysto Compute the Exponential of a Matrix, Twenty-FiveYears Later’ (2003), 45, pp. 3–49.

[32] Niesen, J., Wright, W.M.: ‘Algorithm 919’ ACM Trans.Math. Softw., 2012, 38, (3), pp. 1–19.

[33] Al-Mohy, A.H., Higham, N.J.: ‘Computing the Actionof the Matrix Exponential, with an Application toExponential Integrators’ SIAM J. Sci. Comput., 2011,33, (2), pp. 488–511.

[34] Nielsen, M.A.: ‘Cluster-state quantum computation’Rep. Math. Phys., 2006, 57, (1), pp. 147–161.

[35] Marsaglia, G.: ‘Xorshift RNGs’ J. Stat. Softw., 2003, 8,(14).

[36] Marsland, S.: ‘Machine Learning: An AlgorithmicPerspective, Second Edition’ (CRC Press, 2015).

[37] Kitaev, A.Y., Yu Kitaev, A.: ‘Quantum computations:algorithms and error correction’ (1997), 52, pp.1191–1249.

[38] Suzuki, M.: ‘Fractal decomposition of exponentialoperators with applications to many-body theories andMonte Carlo simulations’ Phys. Lett. A, 1990, 146, (6),pp. 319–323.

[39] Raeisi, S., Wiebe, N., Sanders, B.C.: ‘Quantum-circuitdesign for efficient simulations of many-body quantumdynamics’ New J. Phys., 2012, 14, (10), p. 103017.

[40] Somma, R.D.: ‘A Trotter-Suzuki approximation for Liegroups with applications to Hamiltonian simulation’ J.Math. Phys., 2016, 57, (6), p. 062202.

arX

iv:1

811.

0172

6v3

[qu

ant-

ph]

7 O

ct 2

020

1

Supplementary Material

I. Group Leaders Optimization Algorithm

The Group Leaders Optimization Algorithm (GLOA) is a genetic algorithm that was developed by Anmer Daskinand Sabre Kais in 2010 [1]. One of the primary applications of the algorithm is to find low-cost quantum gatesequences to closely approximate any unitary operator [2]. Generally speaking, the advantage of genetic algorithmscompared to other optimization techniques is that they don’t get stuck in local extremas. We will briefly discuss thealgorithm here, in the context of quantum gate decomposition.

Step I: For any arbitrary unitary operator Ut, consider a set (of considerable size) of gates out of the basicRx, Ry, Rz, Rzz, Pauli-X , Pauli-Y , Pauli-Z, V (square root of Pauli-X), V † , S (π

8gate), T (π

4gate) and H gates along

with their controlled counterparts (refer to the Appendix of [1] for matrix representations of these gates). Which gateset is to be chosen depends on the context and the choice might directly affect the efficiency, precision and convergencetime of the algorithm. One usually tries to choose a universal set of quantum gates. Each gate in the chosen gate setis assigned an index from 1 onwards. For example, if our gate set were V, Z, S, V † we could have numbered themas V = 1, Z = 2, S = 3 and V † = 4. For this algorithm, any single qubit gate can be represented as a four-parameter

string in the form 〈index number of gate〉 〈index of target qubit〉 〈index of control qubit〉 〈angle of rotation〉 . The

index number of the control and target qubits can vary from 1 to total number of qubits (on which U acts) andthe angle of rotation can vary from 0 to 2π. The angle of rotation is represented by positive floating point numberswhereas the indices are represented by natural numbers. The total number of gates in the decomposition is termed asmaxgates, which is restricted to a maximum of 20 in the GLOA. Say the total number of gates in the decompositionis considered to be say m, then the corresponding 4m-parameter string representing the circuit would be of the form

〈gate1〉 〈t.q1〉 〈c.q1〉 〈angle1〉 〈gate2〉 〈t.q2〉 〈c.q2〉 〈angle2〉 ... 〈gatem〉 〈t.qm〉 〈c.qm〉 〈anglem〉 , where t.q and c.q are

abbreviations for ‘target qubit’ and ‘control qubit’ respectively.

Step II: n groups of p such randomly generated 4×maxgates- parameter strings are created. The groups now look asin figure 1. It is important to emphasize that the entire n× p population of strings is randomly generated, followingthe constraints on the index numbers (as described in Step I) and angles (the decimal representing an angle can rangefrom 0 to 2π only).

FIG. 1. In Step II of the algorithm n groups of p randomly generated member strings are created. In step III the leader stringsL-1, L-2,..., L-n are chosen for each group on basis of their trace fidelities.

Step III: For the matrix operator equivalent of any such member string i.e., Ua, we can calculate the value of tracefidelity F , which is defined as

1

N|Tr(UtU

†a)|

where Ut is the operator corresponding to the unitary circuit which we are trying to approximate. It is a measureof the closeness of the two operators Ua and Ut. The values of F can only lie in [0, 1]. This is because the productof two unitary matrices is always unitary and furthermore all eigenvalues of unitary matrices have a magnitude of 1

2

and that the trace of a square matrix is the sum of its eigenvalues. We can clearly see that the higher the value of F ,the greater is the closeness of Ua and Ut. And when Ua = Ut, the trace fidelity is unity. Using this definition, wecalculate the trace fidelities of all the n× p number of member strings. In each of the n groups, the string having thehighest value of trace fidelity is considered to be the leader of that group. So we get n leader strings in each run.

Step IV: In this step we mutate every parameter (element) of all the member strings using a weighted sum involvingthe original string, the leader string and a randomly generated string. Each parameter pr (1 ≤ pr ≤ 4 ×maxgate) ofa member string in any group is modified following the rule:

new stringij [pr] = r1 ×member stringij [pr] + r2 × leader stringi[pr] + r3 × random stringij [pr].

The subscript i, j indicates the i-th member of the j-th group (1 ≤ i ≤ n and 1 ≤ j ≤ p). Since the leader string isshared by all members of a particular group, we use only the single index subscript i for it. random stringij representsa randomly generated string corresponding to the i-th member string of the j-th group. Here r1 + r2 + r3 = 1 and ingeneral the best results are obtained when r1 = 0.8 and r2, r3 are considered to be 0.1 each. We summarize this stepwith the following pseudo-code:

for i = 1 to n dofor j = 1 to p do

for pr = 1 to 4×maxgate donew stringij [pr] = r1 ×member stringij [pr] + r2 × leader stringi[pr] + r3 × random stringij [pr]

end forif fidelity(new stringij) is greater than fidelity(member stringij) then

member stringij = new stringijend if

end for

Step V: In this step we perform one-way crossovers, also known as parameter transfer. The (randomly chosen) pr-thparameter of any random member string k belonging to a group i is replaced with the pr-th parameter of k member ofa randomly chosen group x. It is necessary to keep in mind that only if the trace fidelity of this new string generatedafter crossover is greater than the original fidelity, the original member string is replaced. This is repeated t times for

each group (not for each member). t is a random positive integer bounded above by4×maxgate

2− 1. The pseudo-code

is as follows:

for i = 1 to n do

t = random(4×maxgate

2− 1)

for j = 1 to t dox = random(n)k = random(p)pr = random(4 ×maxgate)new stringik[pr] = member stringxk[pr]if fidelity(new stringik) is greater than fidelity(member stringik) then

member stringik = new stringikend if

end forend for

In the pseudo-code, the random(x) function is basically a function which randomly generates a positive integerbounded by x. Fast pseudo-random generators such as Xorshift [3] or Mersenne twisters [4] may be utilized for thispurpose.

Step VI: The fidelities are re-calculated for all the strings in all the groups. In case the fidelity of any of the leaderstrings surpasses the desired fidelity threshold, the algorithm is terminated and that string with the highest fidelity

3

Randomly generate

n groups of p strings.

START

Choose the leader

string for each group.

Mutate each string ac-

cording to the given rule.

Carry out parameter

transfer for each group,

from other groups.

Calculate the fideli-

ties for all the strings

in all the groups.

Termination

condition

satisfied ?

STOP

No

Yes

FIG. 2. A flowchart representing the steps of the Group Leaders Optimization algorithm

(in the whole population) is returned. We might also terminate the algorithm once a desired number of iterations arecompleted - say 10, 000.

II. Exact Gate Decomposition of the Hamiltonian Simulation Step

Any 4× 4 two-qubit Hamiltonian, which may be represented as a 4× 4 matrix, can be easily decomposed into thefour basic Pauli matrices σ1 = I, σx = X, σy = Y, σz = Z. Say we want to express our two-qubit Hamiltonian H inthe form

H =∑

i,j=1,x,y,z

ai,j(σi ⊗ σj).

4

• Rx(5θ) • Rx(3θ) • S†

• Rx(9θ) ⊕ Y

(a)

• Rx(5θ) • Rx(3θ) • •

• Rx(9θ) ⊕ ⊕ •

(b)

FIG. 3. (a) shows the exact gate decomposition for eiAt. (b) is a simplified version of (a) obtained by combining the two

controlled gates at the end.

Then the coefficients ai,j turn out to be

ai,j =1

4Tr[(σi ⊗ σj)H].

The factor of 14is meant to normalize the Pauli matrices, since ||σi|| =

√

Tr[σ†i σi] =

√2. Using this technique, the

Pauli decomposition of the 4× 4 matrix A i.e.

A =1

4

15 9 5 −3

9 15 3 −5

5 3 15 −9

−3 −5 −9 15

(1)

turns out to be1

A =1

4(15I⊗ I+ 9Z ⊗X + 5X ⊗ Z + 3Y ⊗ Y ).

Neglecting the scaling factor of 14, we note that each one of the terms commute, which implies

eiAθ = e15iθe9iθZ⊗Xe5iθX⊗Ze3iθY⊗Y .

Another observation is that the commuting terms are the stabilizers of the 2-qubit cluster state [5]. So we attempt touse controlled phase gates to get the correct terms. We can rotate the first qubit about the x -axis by an angle 5θ andthe second qubit about the x-axis by angle 9θ. The structure of e3iθX⊗X is a x-rotation on the computational basisstates |00〉, |11〉 and another on |01〉, |10〉. A CNOT gate converts these bases into single qubit bases, controlledoff the target qubit. Since both implement the same rotation but controlled off opposite values, we can remove thecontrol. The overall circuit is shown in figure 3a, which can be further simplified by combining the two controlledgates at the end as in figure 3b.

[1] Daskin, A., Kais, S.: ‘Group leaders optimization algorithm’ Mol. Phys., 2011, 109, (5), pp. 761–772.

1 Courtesy of Dr. Alastair Kay (Royal Holloway, University of London), who also designed the quantum circuits in figures 3a and 3b.

5

[2] Daskin, A., Kais, S.: ‘Decomposition of unitary matrices for finding quantum circuits: application to molecularHamiltonians’ J. Chem. Phys., 2011, 134, (14), p. 144112.

[3] Marsaglia, G.: ‘Xorshift RNGs’ J. Stat. Softw., 2003, 8, (14).[4] Marsland, S.: ‘Machine Learning: An Algorithmic Perspective, Second Edition’ (CRC Press, 2015).[5] Nielsen, M.A.: ‘Cluster-state quantum computation’ Rep. Math. Phys., 2006, 57, (1), pp. 147–161.