Discretization, the Road to Quantum Computing?

*Jesús Lacalle*

### **Abstract**

The main challenge we face in making quantum computing a reality is error control. For this reason it is necessary to study whether the hypotheses on which the threshold theorem has been proved capture all the characteristics of quantum errors. The extraordinary difficulties that we find to control quantum errors effectively together with the little progress in this endeavor, compared to the enormous effort deployed by the scientific community and by companies and governments, should make us reflect on the road map to quantum computing. In this work we analyze error control in quantum computing and suggest that discrete quantum computing models should be explored. In this sense, we present a concrete model but, above all, we propose that Quantum Physics should be taken one step further, in order to allow discretization of the quantum computing model.

**Keywords:** quantum computing errors, quantum threshold theorem, discrete quantum computing errors, continuous quantum computing errors, discrete quantum computing, quantum physics

### **1. Introduction**

Quantum computing is a multidisciplinary research area with extraordinary expectations in Computer Science [1, 2]. It proposes a radical change with respect to the classical computing model, moving to a quantum one. To do this, change the basic unit of classical information, the bit, for the quantum bit or qubit:

$$\begin{aligned} \text{Bit}: & \quad b \in \{0, 1\} \quad \text{and} \\ \text{Qubit}: & \quad q \in \left\{ a\_0|\mathbf{0}\rangle + a\_1|\mathbf{1}\rangle \; | \; a\_0, a\_1 \in \mathbb{C} \text{ and } \; |a\_0|^2 + |a\_1|^2 = \mathbf{1} \right\}. \end{aligned} \tag{1}$$

The superposition principle of Quantum Physics makes the so-called quantum parallelism possible. Working with *n* qubits, quantum parallelism allows 2*<sup>n</sup>* operations to be performed simultaneously. However, making this advantage effective by getting algorithms faster is a difficult challenge. Another important consequence of the superposition principle is the existence of entangled quantum states. The smallest entangled state is built with 2 qubits and is called an EPR pair, because it was first proposed by Einstein, Podolsky and Rosen in 1935:

$$q = \frac{\mathbf{1}}{\sqrt{2}}(|00\rangle + |11\rangle). \tag{2}$$

Another important feature of quantum computing is that it is a continuous computing model. Change a bit, which can only take two discrete values, for a qubit, which is a point on the 3�dimensional unit sphere centered at 0 in the real space 4. This fact makes quantum error control the main challenge for the feasibility of quantum computing. For this reason, one of the main research objectives in the 1990s was to solve this stumbling block. To address the problem, two fundamental tools were developed: quantum error correction codes [3–8] in combination with fault tolerant quantum computing [9–15].

The results obtained seemed to have theoretically solved the problem of quantum error control. The quantum threshold theorem or quantum fault-tolerance theorem was proved. This states that a quantum computer with a physical error rate below a certain threshold can, through application of quantum error correction schemes, suppress the logical error rate to arbitrarily low levels. Shor first proved a weak version [9] and the theorem was independently proven by the groups of Aharanov and Ben-Or [15], Knill, Laflamme and Zurek [13] and Kitaev [14].

All authors use the discrete errors introduced to define error-correcting quantum codes as a key element to prove the quantum threshold theorem. And they do it for two reasons: the constructed quantum codes allow correcting precisely those discrete errors and, even more important, any 1�qubit unitary matrix is a linear combination of those discrete errors. Indeed the discrete errors of a qubit are linear combinations of the well-known Pauli matrices:

$$I = \begin{pmatrix} \mathbf{1} & \mathbf{0} \\ \mathbf{0} & \mathbf{1} \end{pmatrix}, \ X = \begin{pmatrix} \mathbf{0} & \mathbf{1} \\ \mathbf{1} & \mathbf{0} \end{pmatrix}, \ Y = \begin{pmatrix} \mathbf{0} & -i \\ i & \mathbf{0} \end{pmatrix} \text{ and } Z = \begin{pmatrix} \mathbf{1} & \mathbf{0} \\ \mathbf{0} & -\mathbf{1} \end{pmatrix}. \tag{3}$$

However, recent studies [16, 17] indicate that fault-tolerant quantum computing does not cover all the loopholes through which quantum errors escape, accumulating during quantum computations. Lacalle, Pozo-Coronado, Fonseca de Oliveira and Martín-Cuevas model quantum errors as random variables, integrating the essentially continuous character of quantum errors. The first two authors obtain the formula for the variance of the sum of two independent quantum errors *E*<sup>1</sup> and *E*<sup>2</sup> [18]:

$$V(E\_1 + E\_2) = V(E\_1) + V(E\_2) - \frac{V(E\_1)V(E\_2)}{2}.\tag{4}$$

They prove it only for isotropic errors and conjecture that it is true in the general case. The *<sup>n</sup>*�qubits are represented by points on a 2*<sup>n</sup>*þ<sup>1</sup> � <sup>1</sup> �dimensional unit sphere S centered at 0 in the real space <sup>2</sup>*n*þ<sup>1</sup> . Therefore, the variance of the quantum errors of the *<sup>n</sup>*�qubits, unlike what happens in *<sup>n</sup>* , is bounded because the corresponding sphere is a closed and bounded set. In fact the variance always belongs to the interval 0, 4 ½ �.

The authors establish in [16, 17] that a quantum code fixes a quantum error if, assuming that the code's correcting circuit does not introduce new errors, the code reduces the variance of the quantum error. Despite these weak requirements, the authors find two types of quantum error that are not fixed by any quantum code. Let C be the quantum code used, Φ the pure quantum state that the *n*�qubit should have if no error occurs, Ψ the real quantum state of the *n*�qubit generated by the quantum error and Φ~ the code state resulting from applying the code correction circuit to the state Ψ, assuming that this circuit does not introduce new errors. From the point of view of the statistical study of errors, the disturbed state Ψ is a random variable on the sphere S. The same holds for the state Φ~ resulting from the correction, in this case on the corresponding sphere of the subspace code of C (since the accuracy of the correction circuit we are assuming implies that Φ~ belongs to C). The variance of the quantum error is the expected value

$$V(\Psi) = E\left[\|\Phi - \Psi\|^2\right] \tag{5}$$

and the variance of the corrected state *V* Φ~ <sup>¼</sup> *<sup>E</sup>* <sup>∥</sup><sup>Φ</sup> � <sup>Φ</sup><sup>~</sup> <sup>∥</sup><sup>2</sup> . Then <sup>C</sup> fixes the quantum error if:

$$V(\tilde{\Phi}) < V(\Psi). \tag{6}$$

The authors say in [16] that a quantum error Ψ is isotropic if its density function on the sphere S only depends on ∥Φ � Ψ∥ (*θ*0, the first angle in polar coordinates). And they prove the following results:

1. If C detects an error the distribution of Φ~ is uniform ([16], Theorem 3).

2.*V* Φ~ <sup>≥</sup>*V*ð Þ <sup>Ψ</sup> for common probability distributions ([16], Theorem 5).

The first of the above properties indicates that if an error is detected in the code correcting circuit, all information has already been lost in computing. This result, despite being very negative from the point of view of quantum error control, is not surprising for isotropic errors.

The other type of quantum error studied by the authors in [17] is more important: qubit independent errors. They are much more difficult to analyze because they do not have as much symmetry as isotropic errors but they are errors that occur in real quantum computers. To facilitate the analysis, the authors focus on the 5�qubit quantum code because of its high symmetry and argue that the behavior of this quantum code shows a general pattern. Although these two types of errors are very different (the dimension of the support of the isotropic errors is 2*<sup>n</sup>*þ<sup>1</sup> � 1 while that of the qubit independent errors is much smaller: 4*n*), the main results are surprisingly similar. In this case the authors prove the following results:

1. If C detects an error the distribution of Φ~ has central symmetry ([17], Theorem 4.2) and its variance is maximum ([17], Lemma 4.2).

2.*V* Φ~ <sup>≥</sup>*V*ð Þ <sup>Ψ</sup> for common probability distributions ([17], Theorem 4.4).

Note that the second property is the same for both types of quantum error. And, as regards the first, there is not much difference between a uniform distribution on a sphere and a centrally symmetric distribution, if they both approximate a point Φ on the sphere. Therefore, the results for both types of quantum error are similar and this fact is very striking.

Some reviewers have questioned the result of [17] for not considering that quantum states can be multiplied by a phase without physically changing their state. However, the authors of this work introduce the quantum variance that considers this fact,

$$W\_q(\Psi) = E\left[\min\_{\phi} \left( \|\Psi - e^{i\phi}\Phi\|^2 \right) \right],\tag{7}$$

and relate it to the most common error measure in quantum computing, fidelity *F*ð Þ Ψ :

$$1 - \frac{V\_q(\Psi)}{2} \le F(\Psi) \le \sqrt{1 - \frac{V\_q(\Psi)}{2}}.\tag{8}$$

These inequalities show that quantum variance and fidelity are essentially equivalent, since when quantum variance tends to 0, fidelity tends to 1 and, conversely, when fidelity tends to 1, quantum variance tends to 0. Of the three measures, the variance is the only one that allows to complete the complicated calculations performed in [17]. Furthermore, the authors state that the variance and the quantum variance have similar behaviors for continuous quantum computing errors. Indeed, let Φ ¼ ∣0i be a qubit and suppose that Φ is changed by error becoming the state Ψ ¼ *W*Φ, where *W* is the error operator given by Formula (5) in [17] whose density function *f*ð Þ *θ*<sup>0</sup> only depends on the angle *θ*0. Then:

$$\begin{aligned} \Psi &= \left(\cos\left(\theta\_0\right) + i\sin\left(\theta\_0\right)\cos\left(\theta\_1\right)\right)|\mathbf{0}\rangle + \\ &\left(\sin\left(\theta\_0\right)\sin\left(\theta\_1\right)\cos\left(\theta\_2\right) + i\sin\left(\theta\_0\right)\sin\left(\theta\_1\right)\sin\left(\theta\_2\right)\right)|1\rangle \end{aligned} \tag{9}$$

and, taking into account that

$$\min\_{\phi} \left( \|\Psi - e^{i\phi}\Phi\|^2 \right) = 2 - 2|\langle\Psi|\Phi\rangle|\tag{10}$$

and the Eq. (5) we obtain:

$$\begin{aligned} V\_q(X) &= 2 - 4\pi \int\_0^\pi \left( 1 - \frac{\cos^2(\theta\_0)}{2\sin\left(\theta\_0\right)} \log\left(\frac{1-\sin\left(\theta\_0\right)}{1+\sin\left(\theta\_0\right)}\right) \right) \cdot f(\theta\_0) \sin^2(\theta\_0) d\theta\_0 \text{ and } \\ V(X) &= 2 - 4\pi \int\_0^\pi 2\cos\left(\theta\_0\right) \cdot f(\theta\_0) \sin^2(\theta\_0) d\theta\_0. \end{aligned}$$

We observe that the difference between the quantum variance and the variance are the weight functions of *<sup>f</sup>*ð Þ *<sup>θ</sup>*<sup>0</sup> sin <sup>2</sup> ð Þ *θ*<sup>0</sup> in the integral and that they have a similar behavior for small errors, that is, for concentrated density functions *f*ð Þ *θ*<sup>0</sup> around *θ*<sup>0</sup> ¼ 0 (see **Figure 1**).

Even for large errors, for example a uniform distribution function *<sup>f</sup>* <sup>¼</sup> <sup>1</sup> <sup>2</sup>*<sup>π</sup>*2, we have comparable values of the quantum variance and the variance:

**Figure 1.** *Weight functions for quantum variance (red) and variance (blue).*

*Discretization, the Road to Quantum Computing? DOI: http://dx.doi.org/10.5772/intechopen.98827*

$$V\_q(\Psi) = \frac{2}{3} \text{ and } V(\Psi) = 2.\tag{11}$$

In [19], the study of isotropic errors is extended by analyzing the capacity of quantum codes to improve fidelity, and similar results to those presented in [16] are obtained: quantum codes do not improve the fidelity of uncoded quantum states for this type of error.

The results presented in [16, 17, 19] remind us that the quantum computing model is continuous and that the treatment of continuous quantum errors has many subtleties and it is an extraordinarily difficult challenge. Right now we are at a crossroads: extend fault-tolerant quantum computing to error models that include continuous errors or search for a discrete model of quantum computing that allows easier error control. The first road presents formidable difficulties: the fault-tolerant quantum architecture is based exclusively on discrete quantum errors and there is no analogical (continuous) system in the world comparable in complexity to a computer. The second one includes two processes: defining a discrete quantum computing model and finding a quantum system that allows the model to be implemented. It is difficult to know which of the two approaches will lead us to real quantum computing and, for this reason, both should be explored. In this work we study the second one.

A discrete quantum computing model has already been published [20] and, as far as we know, it is the first. In this work Gatti and Lacalle present a discrete quantum computing model based on the following basic requirements:


Of all the possible sets of discrete quantum states, there is one that, fulfilling the first three properties, is the most outstanding in terms of simplicity of the states. It is the set of Gaussian coordinate states, which includes all the quantum states whose coordinates in the computation base, except for a normalization factor ffiffi 2 p �*<sup>k</sup>* , belong to the ring of Gaussian integers:

$$\mathbb{Z}[i] = \{a + bi \: \mid \: a, b \in \mathbb{Z}\}. \tag{12}$$

To define the model they also need to introduce a set of quantum gates that verify the following properties: it contains quantum gates that transform discrete states into discrete states, and it generates all discrete quantum states. And they includes two elementary quantum gates that verify the above properties, *H* and *G*. The Hadamard gate *H* allows superposition, while the other one, *G*, is a 3�qubit quantum gate. Two of them are control qubits, while the third is the target. If the control qubits are in state ∣1i, then the quantum gate *V* is applied to the third qubit:

$$V = \begin{pmatrix} \mathbf{1} & \mathbf{0} \\ \mathbf{0} & i \end{pmatrix}. \tag{13}$$

This quantum gate allows the construction of all Gaussian coordinate states (discrete states) and it is because of this that they call it *G*.

This model of discrete quantum computing is related to Number Theory since discrete quantum states

$$\Phi = \frac{(a\_0 + ib\_0, a\_1 + ib\_1, \dots, a\_{2^\ast - 1} + ib\_{2^\ast - 1})}{\sqrt{2}} \tag{14}$$

must verify the following diophantine equation:

$$a\_0^2 + b\_0^2 + a\_1^2 + b\_1^2 + \dots + a\_{2^\ast - 1}^2 + b\_{2^\ast - 1}^2 = 2^k,\tag{15}$$

where *k*∈ and *a*0, *b*0, … , *a*2*n*�1, *b*2*n*�<sup>1</sup> ∈. The above equation establishes deep connections between the discrete quantum computing model and Lagrange's foursquare theorem. The same authors analyze this relationship in [21].

However, we must go one step further with the model of discrete quantum computing, so do not have the same error handling problem again. We need the discrete quantum states to have a basin of attraction associated with them so that any state that falls inside is automatically self-correcting, transforming into the discrete state. This process is used in the manufacture of hardware for classic computers with enormously satisfactory results.

However, Quantum Physics does not allow the application of this process. First of all, self-correction is not a one-to-one transformation and therefore cannot be unitary. And secondly, it cannot be the result of a quantum measurement either because the probability that the result was not the associated discrete state would be greater than zero. Consequently, we need Quantum Physics to go one step further to have the control that discrete quantum computing requires. Is this possible? We believe that this question should have an affirmative answer if the following one does: Is quantum computing possible?

In the following sections we develop further the ideas presented in this introduction.

### **2. Overview of quantum error control**

Today's quantum error control has two essential components: quantum error correction codes [3–8] and fault-tolerant quantum computing [9–15]. There are textbooks on this subject, such as Gaitan's [22].

#### **2.1 Quantum error correcting codes**

Calderbank and Shor [3] and Steane [4] discovered an important class of quantum error correcting codes. The Calderbank-Shor-Steane (CSS) codes are constructed from two classical binary codes. Another approach to the subject originated the quantum stabilizer codes [5–8]. However, to better understand the role of quantum codes in correcting errors, a general description of them is more useful, without going into the detail of their internal structure.

An quantum error correcting code of dimension ½ � *n*, *m* is a subspace C of dimension *<sup>d</sup>*<sup>0</sup> <sup>¼</sup> <sup>2</sup>*<sup>m</sup>* in the *<sup>n</sup>*�qubit space <sup>H</sup>*<sup>n</sup>*, whose dimension is *<sup>d</sup>* <sup>¼</sup> <sup>2</sup>*<sup>n</sup>*. The <sup>C</sup> quantum code encoding function is a unitary operator *C* that satisfies the following properties:

$$\mathcal{C}: \mathcal{H}^{m} \otimes \mathcal{H}^{n-m} \to \mathcal{H}^{n} \text{ and } \mathcal{C} = \mathcal{C}(\mathcal{H}^{m} \otimes |\mathsf{0}\rangle). \tag{16}$$

The <sup>C</sup> code fixes *<sup>d</sup>*<sup>00</sup> <sup>¼</sup> <sup>2</sup>*<sup>n</sup>*�*<sup>m</sup>* discrete errors: *<sup>E</sup>*0, *<sup>E</sup>*1, … , *Ed*00�1. Since the identity *I* should be among these unitary operators, we assume that *E*<sup>0</sup> ¼ *I*. This process of

discretization of errors allows to correct any of them if the subspaces *Ss* ¼ *Es*ð Þ C , 0≤*s*<*d*00, satisfy the following property:

$$\mathcal{H}^{\mathfrak{n}} = \mathbb{S}\_0 \sqcup \mathbb{S}\_1 \dots \sqcup \mathbb{S}\_{d''-1}.\tag{17}$$

That is, <sup>H</sup>*<sup>n</sup>* is the orthogonal direct sum of said subspaces. Note also that *<sup>S</sup>*<sup>0</sup> <sup>¼</sup> *E*0ð Þ¼ C *I*ð Þ¼ C C. In the stabilized code formalism, the code C is the subspace of fixed states of an abelian subgroup of the Pauli group <sup>P</sup>*<sup>n</sup>* ¼ �f g 1, �*<sup>i</sup>* � f g *<sup>I</sup>*,*X*, *<sup>Z</sup>*, *<sup>Y</sup> <sup>n</sup>* and discrete errors are operators of P*<sup>n</sup>* that anti-commute with any of the subgroup generators, except for the identity operator *E*0. If Formula (17) holds, the code is non-degenerate.

Suppose that a coded state Φ is changed by error, becoming the state Ψ. The initial state is a code state, that is, Φ ∈*S*0, while the final state in general is not, that is, <sup>Ψ</sup> <sup>∉</sup> *<sup>S</sup>*0. If the disturbed state belongs to the subspace *<sup>W</sup>*<sup>Φ</sup> <sup>¼</sup> *L E*0Φ, … , *Ed*<sup>00</sup> ð Þ �1<sup>Φ</sup> , that is, if it is of the form

$$\Psi = a\_0 E\_0 \Phi + \dots + a\_{d'-1} E\_{d'-1} \Phi \quad \text{with} \quad |a\_0|^2 + \dots + |a\_{d'-1}|^2 = \mathbf{1},\tag{18}$$

then the quantum code allows us to retrieve the initial state Φ. To achieve this, we measure Ψ with respect to the orthogonal decomposition of the Formula (17). The result will be *<sup>α</sup><sup>s</sup>* <sup>∣</sup>*αs*<sup>∣</sup> *Es*Φ for a value *s* between 0 and *d*<sup>00</sup> � 1. The value of *s* is called syndrome and allows us to identify the discrete error that the quantum measurement indicates. Then, applying the quantum operator *E*�<sup>1</sup> *<sup>s</sup>* we obtain *<sup>α</sup><sup>s</sup>* <sup>∣</sup>*αs*<sup>∣</sup> Φ. This state is not exactly Φ but, differing only in a phase factor, both states are indistinguishable from the point of view of Quantum Mechanics. Therefore, the code has fixed the error.

An error that does not satisfy Formula (18), that is, it does not belong to *W*Φ, cannot be fixed exactly. For example, if Ψ belongs to the code subspace C, the error cannot be fixed at all since, being a code state, it is assumed that it has not been disturbed. Therefore it is important to analyze the limitation in the correction capacity of an arbitrary code, assuming that the code correction circuit does not introduce new errors.

Finally, we want to highlight that discrete errors can be chosen so that, for example, all errors affecting a single qubit are fixed. The best code with this feature that encodes one qubit is the 5-qubit quantum code [23, 24]. This code is optimal in the sense that no code with less than 5 qubits can fix all the errors of one qubit.

#### **2.2 Fault-tolerant quantum computing**

Fault-tolerant quantum computing was proposed with the aim of proving the quantum threshold theorem or quantum fault-tolerance theorem: a quantum computer with a physical error rate below a certain threshold can, through application of quantum error correction schemes, suppress the logical error rate to arbitrarily low levels. Shor first proved a weak version [9] and the theorem was independently proven by the groups of Aharanov and Ben-Or [15], Knill, Laflamme and Zurek [13] and Kitaev [14].

The essential elements of fault-tolerant quantum computing [9, 13, 15] are as follows: the encoding of each of the qubits with quantum error-correcting codes, the use of fault-tolerant quantum gates, the application of quantum gates on coded qubits (encoded operations) and the concatenation of quantum error-correcting codes.

Another essential element for the proof of the quantum threshold theorem is the quantum error model used. Shor [9] assumes that there is no decoherence error and considers that in a quantum gate an error occurs with probability *p* and that the errors corresponding to different qubits are independent. Therefore the probability that errors will occur in *k* qubits simultaneously is:

$$\text{Prob}(k \text{ errors}) = \binom{n}{k} (1-p)^{n-k} p^k. \tag{19}$$

Knill, Laflamme and Zurek [13] and Aharanov and Ben-Or [15] consider both decoherence errors and errors in quantum gates and also assume the independence of errors on different qubits. The first [13] analyze quasi-independent and monotonic errors with error strength *p* and bound *C*: the total strength of the summands for which at least a given *k* many error locations have failed is at most *Cpk* . Aharanov and Ben-Or [15] use density matrices and model the error in a qubit as follows:

$$(1 - p)I + pE.\tag{20}$$

In all cases, the parameter *p* can be considered as the probability that an error occurs in a qubit and therefore the probability that *k* errors coincide in different qubits will be proportional to *p<sup>k</sup>*. This consideration is key in proving the quantum threshold theorem and as such it appears in Gaitan's textbook [22] (see for example Table 1.1 on page 38). The errors associated with *p* are arbitrary and include what Shor calls "fast" errors and also "slow" errors. In particular they include the errors described by the Pauli matrices (3). This error model is the discretized quantum error model or the stochastic quantum error model.

The discretized quantum error model together with the concatenation of errorcorrecting quantum codes are the key elements in the proof of the quantum threshold theorem. The effect of the conjugation of both is as follows (see for example Figure 6 in [13]):


where we have used the 7�qubit CSS code. In each encoding the error in a qubit is fixed by the code and only errors of order 2 or greater remain. This scheme makes the error small, since *pk* tends to zero if *k* grows.

But this approach cannot be used in all cases, for example for the decoherence error, since in this case the reality is different: the probability of errors occurring in all qubits is 1, although on the other hand the errors with high probability are small. In this situation the correcting code cannot handle a simultaneous error in all qubits and neither can it correct the "lower order" errors. Here is the essential difference between the discrete error model and the continuous one. The discrete error model does not fit this situation, in which small errors are not controlled and, after the application of the code correction circuit, become undetectable (because the resulting state belongs to the subspace code) and accumulate during computation.

Another key to fault-tolerant quantum computing is to avoid quantum gates that act on two qubits belonging to the same quantum code instance (implementation of fault-tolerant quantum gates for the used quantum code). In this way, the imprecision of the quantum gates only introduces error in at most one qubit of each instance of the quantum code. However, the error in 2�qubit quantum gates is not reduced to an error in each of the qubits. It also generates an error that affects both *Discretization, the Road to Quantum Computing? DOI: http://dx.doi.org/10.5772/intechopen.98827*

qubits simultaneously (entangled error) and the code instances to which the two qubits belong are not designed to tackle it.

The use of an instance of an error correcting quantum code of dimension ½ � *n*, 1 on each of the qubits of a quantum circuit (algorithm) produces two additional effects to consider. First, this multiplies the number of qubits in the circuit by *n*. As a consequence, the decoherence per unit of time that occurs in the circuit is multiplied by *n*. Second, the number of gates in the circuit is multiplied by at least *n n*ð Þ þ 1 . Each encoded quantum gate requires a minimum of *n* quantum gates and, after each one of them, the code correction circuit must be applied, that is, at least another *n* quantum gates or measurements are needed. The effect of this increasing number of quantum gates is that the imprecision errors are multiplied by *n n*ð Þ þ 1 . A total of at least *n*<sup>2</sup> of these quantum gates and measurements correspond to the correction circuits and are therefore not protected. This fact remains even if we concatenate quantum codes in the last application of the error correcting code. If the number of quantum gates in an algorithm is *n* and the error correcting code is concatenated *k* times, the final number of gates is at least *n*<sup>2</sup>*<sup>k</sup>* . Then, the ratio of quantum gates not protected from imprecision errors is at least

$$1 - \frac{1}{n^{2^{k-1}}}.\tag{22}$$

Finally, it should be noted that the use of quantum codes produces an additional increase in decoherence by increasing the execution time of the algorithms.

Despite the difficulties raised above for the effective control of quantum errors, the discrete quantum error model or stochastic quantum error model allows the proof of the quantum threshold theorem. But unfortunately this model of quantum computing errors does not allow a realistic analysis of continuous quantum computing errors. These break the golden rule of error correction: all small errors must be corrected. The road of fault-tolerant quantum computing goes through including continuous errors in the quantum threshold theorem. This is a huge challenge and for this reason it is interesting to investigate other possible roads.

### **3. Discrete quantum computing**

We are interested in discrete quantum computing because it could lead us to a quantum computing where error control was an easier challenge. In the literature there are some works on discrete quantum computing. They generally intend to simplify or better understand the quantum model: introducing modal concepts and finite fields for the representation of quantum amplitudes [25–29], using discretization for the design of algorithms [30], relating the structures of computation and the foundations of physics [31–38] and studying universal sets of discrete quantum gates [39–43].

As we have already commented in the Introduction, a discrete quantum computing model has already been published [20]. It is a model in which discretization is applied both to quantum states and to quantum gates and that aims to become independent from the standard quantum model (continuous model) and even, if possible, from continuous hardware (Quantum Physics). The presented discrete quantum computing model is based on the following basic requirements:


3. It allows to approximate general quantum states.

4. It contains simple quantum states.

Of all the possible sets of discrete quantum states, there is one that, fulfilling the first three properties, is the most outstanding in terms of simplicity of the states. It is the set of Gaussian coordinate states, which includes all the quantum states whose

coordinates in the computation base, except for a normalization factor ffiffi 2 p �*<sup>k</sup>* , belong to the ring of Gaussian integers:

$$\mathbb{Z}[i] = \{a + bi \: \mid \: a, b \in \mathbb{Z}\}.\tag{23}$$

To define the model the authors introduce a set of elementary quantum gates that verify the following properties: it contains quantum gates that transform discrete states into discrete states, and it generates all discrete quantum states. This set includes two quantum gates that verify the above properties, *H* and *G*. The Hadamard gate *H* allows superposition, while the other one, *G*, is a 3�qubit quantum gate. Two of them are control qubits, while the third one is the target. If the control qubits are in state ∣1i, then the quantum gate *V* is applied to the third qubit:

$$V = \begin{pmatrix} \mathbf{1} & \mathbf{0} \\ \mathbf{0} & i \end{pmatrix}. \tag{24}$$

This model of discrete quantum computing is related to Number Theory since discrete quantum states

$$\Phi = \frac{(a\_0 + ib\_0, a\_1 + ib\_1, \dots, a\_{2^\ast - 1} + ib\_{2^\ast - 1})}{\sqrt{2}} \tag{25}$$

must verify the following diophantine equation:

$$a\_0^2 + b\_0^2 + a\_1^2 + b\_1^2 + \dots + a\_{2^\ast - 1}^2 + b\_{2^\ast - 1}^2 = 2^k,\tag{26}$$

where *k*∈ and *a*0, *b*0, *a*1, *b*1, … , *a*2*n*�1, *b*2*n*�<sup>1</sup> ∈ .

As we will see in the next subsection, the level of a discrete state is defined as the lowest natural number *k* for which the previous diophantine Eq. (26) holds. The superposition principle of Quantum Physics is satisfied in the following case: Given orthogonal discrete states Φ0, Φ1, … , Φ *<sup>j</sup>*�<sup>1</sup> belonging to levels *k*0, *k*1, … , *k <sup>j</sup>*�<sup>1</sup> respectively, then the following linear combinations are also discrete quantum states:

$$\Phi = \frac{(c\_0 + id\_0)}{\sqrt{2^{k\_0'}}} \Phi\_0 + \frac{(c\_1 + id\_1)}{\sqrt{2^{k\_1'}}} \Phi\_1 + \dots + \frac{(c\_{j-1} + id\_{j-1})}{\sqrt{2^{k\_{j-1}'}}} \Phi\_{j-1} \tag{27}$$

where *k*<sup>0</sup> 0, *k*<sup>0</sup> 1, … , *k*<sup>0</sup> *<sup>j</sup>*�<sup>1</sup> <sup>∈</sup> , *<sup>k</sup>*<sup>0</sup> <sup>þ</sup> *<sup>k</sup>*<sup>0</sup> 0, *k*<sup>1</sup> þ *k*<sup>0</sup> 1,, *k <sup>j</sup>*�<sup>1</sup> þ *k*<sup>0</sup> *<sup>j</sup>*�<sup>1</sup> have the same parity, *c*0, *d*0,*c*1, *d*1, … ,*c <sup>j</sup>*�1, *d <sup>j</sup>*�<sup>1</sup> ∈ and

$$\frac{c\_0^2 + d\_0^2}{\mathfrak{L}^{k\_0'}} + \frac{c\_1^2 + d\_1^2}{\mathfrak{L}^{k\_1'}} + \dots + \frac{c\_{j-1}^2 + d\_{j-1}^2}{\mathfrak{L}^{k\_{j-1}'}} = \mathbf{1}.\tag{28}$$

The superposition principle is also satisfied for non-orthogonal discrete states. For example for the following two discrete states of level 4:

*Discretization, the Road to Quantum Computing? DOI: http://dx.doi.org/10.5772/intechopen.98827*

$$\begin{aligned} \Phi\_0 &= \frac{1}{4}(1+i, 1+2i, 0, 3) \\ \Phi\_1 &= \frac{1}{4}(1+i, 0, 1+2i, 3) \end{aligned} \qquad \Phi = \frac{5+9i}{8}\Phi\_0 - \frac{3+9i}{8}\Phi\_1. \tag{29}$$

Discrete state Φ has level 10, result of the sum of the levels of states Φ<sup>0</sup> and Φ1, 4, and of coefficients used in the combination, 6.

#### **3.1 Discrete quantum states**

The quantum gates *H* and *G*, along with two auxiliary qubit (ancilla qubits), allow to perform a wide set of operations, for example, any permutation of the states of the computational base B and adding a factor �1, *i* or �*i* to any subset of coordinates of an n-qubit, with respect to the computational base B, where:

$$\begin{aligned} \mathcal{B} &= [|\mathbf{0}\rangle, |\mathbf{1}\rangle, |\mathbf{2}\rangle, |\mathbf{3}\rangle, |\mathbf{4}\rangle, |\mathbf{5}\rangle, |\mathbf{6}\rangle, |\mathbf{7}\rangle, |\mathbf{8}\rangle, \dots, |\mathbf{2}^n - \mathbf{1}\rangle] \text{ or } \\\\ \mathcal{B} &= [|\mathbf{0}\cdots\mathbf{0}\mathbf{0}\rangle, |\mathbf{0}\cdots\mathbf{0}\mathbf{1}\rangle, |\mathbf{0}\cdots\mathbf{1}\mathbf{0}\rangle, |\mathbf{0}\cdots\mathbf{1}\rangle, \dots, |\mathbf{1}\cdots\mathbf{1}\rangle]. \end{aligned} \tag{30}$$

They also allow obtaining other quantum gates that are commonly used: *X*, <sup>Λ</sup>*<sup>X</sup>* <sup>¼</sup> *Cnot*, <sup>Λ</sup><sup>2</sup> *<sup>X</sup>* <sup>¼</sup> *Toffoli*, *<sup>Z</sup>*, <sup>Λ</sup>*Z*, <sup>Λ</sup><sup>2</sup> *Z*, *V* and Λ*V*.

The set of discrete quantum states E is defined as follows: E is the smallest set of quantum states which contains the computational base and is invariant under the application of the conforming gates *H* and *G*. As a consequence of the properties of *H* and *G* discussed above, the set E is also invariant by any permutation of coordinates and by the addition of a factor �1, *i* or �*i* to any subset of coordinates.

The conforming quantum gates *H* and *G* have been chosen in order to generate exactly the states whose coordinates are Gaussian integers (except for a normalization factor of the form ffiffi 2 <sup>p</sup> �*<sup>k</sup>* where *<sup>k</sup>*<sup>∈</sup> ) that is, elements of the set ½ �*<sup>i</sup>* defined in Formula (23).

The set of Gaussian coordinate states *E* is defined by the following property: a

quantum state Φ ∈*E* if and only if there exists *k*∈ such that ffiffi 2 p *<sup>k</sup>* <sup>Φ</sup> <sup>∈</sup> ½ �*<sup>i</sup>* <sup>2</sup>*<sup>n</sup>* . And, as we have already commented before, the set of discrete states E and the set of Gaussian coordinate states *E* are the same. Consequently every discrete state must verify the Eq. (25), for a certain value *k*∈ , and its coordinates without the normalization factor the diophantine Eq. (26).

Discrete states are classified by levels. We say that a discrete state Φ is at level *k*∈ if *k* is the smallest natural number for which it is verified that ffiffi 2 p *<sup>k</sup>* <sup>Φ</sup> <sup>∈</sup>½ �*<sup>i</sup>* <sup>2</sup>*<sup>n</sup>* . From Eq. (25) it is concluded that there is a one-to-one relationship between the discrete states and the integer solutions of the Eq. (26) in which at least one component (real or imaginary part) of one coordinate is odd.

Given *k*∈ , we call *Ek* to the set of discrete states of level *k*. These sets verify the following properties: for all *k*∈ *Ek* is finite, in fact its size is bounded by the number of solutions of the diophantine Eq. (26); and for all *k*1, *k*<sup>2</sup> ∈ , *k*<sup>1</sup> 6¼ *k*2, it holds *Ek*<sup>1</sup> ∩ *Ek*<sup>2</sup> ¼ ∅.

Given a number *k*∈ , the set of discrete states with a level less than or equal to *k*, *E*≤*<sup>k</sup>*, allows us to approximate a general quantum state with a precision of the order of ffiffi 2 p �*<sup>k</sup>* . In this sense, the set of discrete states *E* allows us to approximate general quantum states and, as the level of the discrete states increases, the approximation is more precise. Finding the best approximation of a general quantum state through a discrete state in *E* <sup>≤</sup>*<sup>k</sup>*, *k*≥0, is a natural problem that allows us to relate

discrete quantum computing with quantum computing. This problem is also related to Number Theory because the discrete states must verify the diophantine Eq. (26).

In discrete quantum computing, the parity and the parity pattern of the coordinates are important. Given a coordinate *a* þ *ib*∈½ �*i* these concepts are defined as follows:

$$\begin{aligned} \text{P}(a+ib) &= a+b \mod 2 \text{ and} \\ \text{PP}(a+ib) &= (a \mod 2, b \mod 2). \end{aligned} \tag{31}$$

From formula (26) it is easy to deduce that the number of coordinates with parity 1 in a discrete state of level *k*≥ 1 is even.

The proof that the set of discrete states E is the same as the set of Gaussian coordinate states *E* illustrates well the structure of these sets and uses as key elements the concepts introduced above. The non-trivial part of this proof consists of giving a procedure (algorithm) to construct a state of *E* starting from a vector of the computational base, ∣0i for example, and applying the quantum gates *H* and *G* repeatedly. Gate *H* changes the level of all discrete state, most of the time increasing it by 1. But they also reduce by 1 the level of the states that we call "reducible". For example, the gate *H* applied to the nth-qubit, *Hn*, produces the following change in the discrete quantum state:

$$\begin{aligned} \frac{1}{\sqrt{2}}(a\_0 + ib\_0, a\_1 + ib\_1, \dots) &\rightarrow \\ \frac{1}{\sqrt{2}}((a\_0 + a\_1) + i(b\_0 + b\_1), (a\_0 - a\_1) + i(b\_0 - b\_1), \dots). \end{aligned} \tag{32}$$

Therefore, for the state to be reducible, all the coordinates of the state resulting from the application of *Hn* must be multiples of 2. In this case, the initial increment by 1 of the discrete state level becomes a decrement by 1, by dividing the coordinates by 2. This division by 2 is compensated by multiplying the normalization factor ffiffi 2 <sup>p</sup> �ð Þ *<sup>k</sup>*þ<sup>1</sup> by 2, that is, reducing its exponent by 2. Consequently, a state is reducible by applying *Hn* if its coordinates, taken two by two, have the same parity pattern:

$$\begin{array}{llll}\text{Pattern} & (0,0): & (even, even) & - & (even, even),\\\text{Pattern} & (0,1): & (even, odd) & - & (even, odd),\\\text{Pattern} & (1,0): & (odd, even) & - & (odd, even),\\\text{Pattern} & (1,1): & (odd, odd) & - & (odd, odd).\end{array} \tag{33}$$

The proof starts from a discrete state of level *k*∈ and, applying the quantum gates *H* and *G*, its level is reduced, one by one, to level 0 and, once this is done, it is transformed into a state of the computational base. Then the construction of the state consists of writing this product of quantum gates in reverse order and substitute *G* for its inverse *G*<sup>3</sup> . The keys of the proof are as follows. First, all the coordinates with the parity pattern 0, 1 ð Þ are multiplied by *i*, so that all coordinates with parity 1 have the parity pattern 1, 0 ð Þ. Secondly, the coordinates are permuted so that the parity patterns 1, 0 ð Þ appear at the end of the vector and, just before, the largest possible even number of patterns 1, 1 ð Þ and the largest possible even number of patterns 0, 0 ð Þ.

If all the coordinates are already placed, the state is reducible. Otherwise the first two coordinates will have parity patterns 0, 0 ð Þ and 1, 1 ð Þ and the application of the quantum gate

*Discretization, the Road to Quantum Computing? DOI: http://dx.doi.org/10.5772/intechopen.98827*

$$R = V\_1 H\_n V\_1 H\_n,\tag{34}$$

where *V*<sup>1</sup> multiplies the second coordinate by *i* and *Hn* is the application of the quantum gate *H* to the last qubit, will solve the problem:

$$R\Phi = \frac{1}{\sqrt{2}} \left( \frac{a\_0 - b\_0 + a\_1 + b\_1}{2} + i \frac{a\_0 + b\_0 - a\_1 + b\_1}{2},$$

$$\frac{a\_0 - b\_0 - a\_1 - b\_1}{2} + i \frac{a\_0 + b\_0 + a\_1 - b\_1}{2}, a\_2 + i b\_2, \dots \right). \tag{35}$$

The quantum gate *R* plays an important role in discrete quantum computing. It modifies (rotates) the parity patterns of the first two coordinates of the *n*-qubit as shown in **Figure 2**.

#### **3.2 Discrete quantum gates**

The introduced discrete quantum computing model satisfies some properties that the authors did not expect to hold. They define discrete quantum gates as the quantum gates that leave the set of discrete states invariant. This means that a quantum gate is discrete if applying it to any discrete state produces another discrete state as a result.

Discrete quantum gates are characterized by a simple property: a quantum gate is discrete if and only if the columns of its matrix, with respect to the computational base, are discrete states with levels of the same parity. This characterization is also fulfilled by substituting the columns of the matrix for the rows, since the matrix is unitary.

The number of discrete gates of one-qubit is finite because the number of discrete states of one-qubit is also finite: 8 discrete states of level 0, 24 of level 1, 16 of level 2 and none of level greater than or equal to 3. In this case all discrete gates can be generated from *H* and *G*.

Like discrete states, discrete gates are classified by levels. The level of a discrete gate is defined as the highest of the levels of its columns, considered as discrete

**Figure 2.** *Rotation of the parity patterns by the quantum gate R.*

states. Obviously if we defined the level of a discrete gate using the rows instead of the columns, the result would be the same.

To proof that a discrete gate can be obtained as a product of gates *H* and *G*, it is enough to show that its level can be reduced, one by one, by left and right multiplying by these gates. This is possible only if we can make the discrete states of all its columns simultaneously reducible. And this surprisingly is possible!

Gatti and Lacalle prove it for discrete two-qubit quantum gates and conjecture that the result is true for any number of qubits. To do this, they generalize the properties of the parity patterns already introduced to the discrete gates (see **Figure 3**). They introduce the following concepts:


From this definition and taking into account that the columns of a discrete gate are orthogonal discrete states, we can observe:

1.The number of odd elements in any column of a discrete gate is even.

2.Given two columns of a discrete gate, the number of simple matches and the number of cross matches are even.

We remark that every result about the columns of a quantum gate is also valid for the rows, since the matrix is unitary.

As it happened with the quantum states, we need to appeal to the gates *R* and *R<sup>t</sup>* (transpose of *R*), which will act on the left and on the right, respectively. The gate *R<sup>t</sup>* also produces a rotation of the coordinate parity patterns, analogously to the way *R* does (see **Figure 2**). However in this case the rotation is in the opposite direction.

The proof that discrete two-qubit quantum gates can be generated from gates *H* and *G* is much more technical than that described for discrete states. The parity constraints of the rows and columns of the discrete gates, derived from their unitarity, are sufficient tools to complete the proof. Readers interested in the details of this demonstration can refer to the original article [20]. The techniques used in the proof do not generalize for discrete gates of more than two qubits, but authors believe that the result is true in general.

**Conjecture 1.** For all *n* ≥3 every dicrete *n*-qubit quantum gate can be decomposed into a product of *H* and *G* quantum gates.

**Figure 3.** *Odd coordinate component matches.*
