Block synchronization for quantum information

Locating the boundaries of consecutive blocks of quantum information is a fundamental building block for advanced quantum computation and quantum communication systems. We develop a coding theoretic method for properly locating boundaries of quantum information without relying on external synchronization when block synchronization is lost. The method also protects qubits from decoherence in a manner similar to conventional quantum error-correcting codes, seamlessly achieving synchronization recovery and error correction. A family of quantum codes that are simultaneously synchronizable and error-correcting is given through this approach.


I. INTRODUCTION
The field of quantum information theory has experienced rapid and remarkable progress toward understanding and realizing large-scale quantum computation and quantum communication. One of the most important missions is to develop theoretical foundations for robust and reliable quantum information processing. The discovery of the fact that it is even possible for us to correct the effects of decoherence on quantum states was one of the most important landmarks in quantum information theory in this regard [1]. The field has since made various kinds of remarkable progress, from developing quantum analogues of important concepts in classical information theory to finding surprising phenomena that are uniquely quantum information theoretic [2]. Quantum error correction has been realized in various experiments as well [3][4][5][6][7][8][9][10][11].
One of the most important problems on reliable quantum information processing that remain unaddressed, however, is block synchronization (or, more commonly, "frame synchronization" in the language of classical communications [12]). In classical digital computation and communications, virtually all data have some kind of block structure, which means that in order for one to make sense of data, one must know the exact positions of the boundaries of each block of information, or word, in a stream of bits. This fact will stay the same in the quantum domain. In fact, not only will the actual quantum information one wishes to process most likely have a block structure for the same reason as in the classical domain, but procedures for manipulating quantum information also typically demand very precise alignment. For instance, we have a means to encode one qubit of information into five physical qubits to reduce the effects of decoherence to the theoretical limit [13]. However, this does not mean that we can apply the procedure to, say, the last three qubits * yuichiro.fujiwara@caltech.edu from an encoded quantum state and the first two qubits from the following information block to correct errors. If that worked, one would still not be able to correctly interpret the information carried by the qubits; after all, "quantum information theory" is not quite the same as "antumin formationth eory" with "qu" before it.
Block synchronization is critical when correct block alignment can not be provided or is difficult to provide by a simple external mechanism. For instance, block synchronization is a critical problem in virtually any area of classical digital communications, where two parties are physically distant, so that synchronization must be achieved through some special signaling procedure, such as inserting "marker" bits or using a specially allocated bit pattern as "preamble" to signal the start of each block (see, for example, [14,15] for the basics of block synchronization techniques for digital communications).
It is true that if we assume that a qubit always goes through wires as expected in a quantum circuit and that storing, retrieval, and transmission of quantum information are always securely synchronized by external physical mechanisms, then block synchronization is certainly not a problem. However, such a strict assumption imposes demanding requirements on hardware and limits what quantum information processing can offer. For example, without a software solution to block synchronization, quantum communication would have to always be supported by perfectly synchronized classical communications to a large degree [16].
One of the most substantial barriers to establishing block synchronization in the quantum domain is the fact that measuring qubits usually destroys the quantum information they contain. Existing classical block synchronization techniques typically require that the information receiver or processing device constantly monitor the data to pick up on inserted boundary signals, which translates into constant measurement of all qubits in the quantum case. Hence, if an analogue of a classical synchronization scheme such as inserting preamble were to be employed in a naive manner, one would have to know exactly where those inserted boundary signals are in order not to disturb quantum information contained in data blocks, which would require accurate synchronization to begin with.
One might then expect that a sophisticated block synchronization scheme based on information theory would be more attractive and promising in the quantum world. Another big hurdle lies exactly here; sophisticated coding for synchronization is already a notoriously difficult problem in classical information theory (see, however, [17] for a recent survey of coding theoretical approaches to fighting various kinds of synchronization error for the classical case). Making things more challenging, quantum bits are thought to be more vulnerable to environmental noise than classical bits, which implies that we ought to simultaneously answer the need for strong protection from the effects of decoherence.
The primary purpose of the present paper is to show that it is, indeed, possible to encode information about the boundaries of blocks into qubits in such a way that block synchronization recovery and quantum error correction are seamlessly integrated. The proposed scheme does not rely on external synchronization mechanisms or destroy quantum information by searching for boundaries. We make use of classical error-correcting codes with certain algebraic properties, so that the problem of finding such quantum synchronizable error-correcting codes is reduced to that of searching for special classical codes.
In the next section, we give a simple mathematical model of block synchronization in the quantum domain and define quantum synchronizable error-correcting codes. The details of our scheme is presented in Section III. Concluding remarks are given in Section IV.

II. BLOCK SYNCHRONIZATION
Here we give a simple mathematical model of block synchronization in the quantum setting. Note that while the term block might seem to suggest that each block is encoded by the same block code, we may treat them as more general structures, so that different blocks can contain different numbers of qubits encoded by different coding schemes.
Let Q = (q 0 , . . . , q x−1 ) be an ordered set of length x, where each element represents a qubit. A block F i is a set of consecutive elements of Q. Let F = {F 0 , . . . , F y−1 } be a set of blocks. The ordered set (Q, F ) is called a blockwise structured sequence if |{ i F i }| = x and F i ∩ F j = ∅ for i = j. In other words, the elements of a sequence are partitioned into groups of consecutive elements called blocks.
Take a set G = {q j , . . . , q j+g−1 } of g consecutive elements of Q. G is said to be misaligned by a qubits to the right with respect to (Q, F ) if there exits an integer a and a block F i such that F i = {q j−a , . . . , q j+g−a−1 } and G ∈ F . If a is negative, we may say that G is misaligned by |a| qubits to the left. G is properly aligned if G ∈ F .
To make this mathematical model clearer, take three qubits and encode each qubit into nine qubits by Shor's nine qubit code [1]. The resulting 27 qubits may be seen as Q = (q 0 , . . . , q 26 ), where the three encoded nine qubit blocks |ϕ 0 , |ϕ 1 , and |ϕ 2 form blocks F 0 = (q 0 , . . . , q 8 ), F 1 = (q 9 , . . . , q 17 ), and F 2 = (q 18 , . . . , q 26 ) respectively. These 27 qubits may be sent to a different place, stored in quantum memory or immediately processed for quantum computation. A device, knowing the size of each information block, operates on nine qubits at a time. If misalignment occurs by, say, two qubits to the left, the device that tries to correct errors on qubits in |ϕ 1 applies the error correction procedure to the set G of nine qubits q 7 , . . . , q 15 , two of which come from F 0 and seven of which F 1 . In this case, when measuring the stabilizer generator IZZIIIIII of the nine qubit code to obtain the syndrome, what the device actually does to the whole system can be expressed as which, if block synchronization were correct, would be I ⊗8 Z does not stabilize |ϕ 0 , nor does ZI ⊗8 |ϕ 1 . Hence, errors are introduced to the system, rather than detected or corrected. Similarly, if the same misalignment happens during fault-tolerant computation, the device that tries to apply logicalX to the third logical block |ϕ 2 will apply I ⊗16 X ⊗9 II to the 27 qubit system. Other kinds of synchronization error such as deletion may be considered in the quantum setting (see [17] for mathematical models of such errors in the classical case). As in the classical coding theory, however, we would like to separately treat them and do not consider fundamentally different types of synchronization in the current paper. Instead, we assume that no qubit loss or gain in the system occurs and that a device regains access to all the qubits in proper order in the system if misalignment is correctly detected.
Our objective is to ensure that the device identifies, without destroying quantum states, how many qubits off it is from the proper alignment should misalignment occur. A code that is designed for detecting this type of misalignment is called a synchronizable code in the modern information theory literature. Borrowing this term, we call a coding scheme a quantum synchronizable (a l , a r )-[[n, k]] code if it encodes k logical qubits into n physical qubits and corrects misalignment by up to a l qubits to the left and up to a r qubits to the right.
We assume that a linear combination of I, X, Z, and Y acts on each qubit independently over a noisy quantum channel. For error correction against such errors, we employ a version of syndrome decoding and show how to correct errors. In principle, the true values of the minimum distances of our quantum synchronizable codes can be computed. However, we focus on how many nontrivial quantum errors our decoding procedure can correct. Hence, the actual minimum distances of our quantum synchronizable codes may be larger than what our decoding algorithm suggests.
In what follows, we give a general construction for quantum synchronizable error-correcting codes and describe the procedures of encoding, error correction, synchronization recovery, and decoding. An infinite class of such quantum codes will be given at the end of the next section as an example.

III. CODING SCHEME
In this section we give the mathematical details of our solution and show how to realize quantum synchronizable codes. We employ classical and quantum coding theory. For the basic facts and notions in classical and quantum coding theories, the reader is referred to [2,18].

A. Preliminaries
As usual, we define a binary linear [n, k] code as a k-dimensional subspace of F n 2 , the n-dimensional vector space over the binary field. Because we do not consider a code over another field, we always assume that a classical code is binary unless otherwise stated.
A cyclic code C is a linear [n, k] code with the property that if c = (c 0 , . . . , c n−1 ) is a codeword of C, then so is every cyclic shift of c. It is known that, by regarding each codeword as the coefficient vector of a polynomial in F 2 [x], a cyclic code can be seen as a principal ideal in the ring F 2 [x]/(x n − 1) generated by the unique monic nonzero polynomial g(x) of minimum degree in the code which divides x n − 1. Computations in F 2 [x]/(x n − 1) are modulo x n − 1. A cyclic shift thus corresponds to multiplying by x, and the code can be written as C = {i(x)g(x) | deg(i(x)) < k}. Multiplying by x is an automorphism. The orbit of a given codeword i(x)g(x) by this group action is written as Let C and D be two linear codes of the same length. 2 ⌋ quantum errors can be corrected through a separate twostep error correction procedure by directly exploiting the error correction mechanism of the corresponding classical code. A higher quantum error correction capability may be achieved if the code is degenerate. For the sake of simplicity, however, we do not investigate the degeneracy of each individual quantum error-correcting code. In the remainder of this paper, we assume familiarity with the structure of CSS codes as well as their basic encoding and decoding mechanisms given in a standard textbook such as [2].

B. Main theorem
Our main theorem employs a pair of cyclic codes C and D satisfying C ⊥ ⊆ C ⊂ D to generate a quantum synchronizable code.
Theorem 1 If there exist a dual-containing cyclic [n, k 1 , d 1 ] code C and a C-containing cyclic [n, k 2 , d 2 ] code with k 1 < k 2 , then for any pair of nonnegative integers a l , a r satisfying a l + a r < k 2 − k 1 there exists a quantum synchronizable (a l , a r )-[[n + a l + a r , 2k 1 − n]] code that corrects at least up to ⌊ d1−1 2 ⌋ phase errors and at least up to ⌊ d2−1 2 ⌋ bit errors. To prove Theorem 1, we realize a quantum synchronizable code as a carefully translated vector space similar to a CSS code. The proof of the above theorem will be completed in Section III D 5 after describing encoding and decoding procedures in Section III C and Sections III D 1-4.
Let C be a dual-containing cyclic [n, k 1 , d 1 ] code that lies in another cyclic [n, k 2 , d 2 ] code D with k 1 < k 2 . Define g(x) as the the generator of D = g(x) which is the unique monic nonzero polynomial of minimum degree in D. Define also h(x) as the generator of C which is the unique monic nonzero polynomial of minimum degree in C. Since C ⊂ D, the generator g(x) divides every codeword of C. Hence, h(x) can be written as h(x) = f (x)g(x) for some polynomial f (x) of degree n − k 1 − deg(g(x)) = k 2 − k 1 .
For every polynomial j(x) = j 0 +j 1 x+· · ·+j n−1 x n−1 of degree less than n, define |j(x) as the n qubit quantum state |j(x) = |j 0 |j 1 · · · |j n−1 . For a set J of polynomials of degree less than n, we define |J as Because R is a system of representatives, these 2 2k1−n states form an orthonormal basis. Let V g be the vector space of dimension 2 2k1−n spanned by V g . We employ this translated space V g to prove Theorem 1.

C. Encoding
Take a full-rank parity-check matrix H D of D. For each row of H D , replace zeros with Is and ones with Xs.
Perform the same replacement with Is for zeros and Zs for ones. Because C ⊥ ⊂ C ⊂ D implies D ⊥ ⊂ D, the code D is a dual-containing cyclic code of dimension k 2 . Hence, the resulting 2(n−k 2 ) Pauli operators on n qubits form stabilizer generators S D of the Pauli group on n qubits that fixes a subspace of dimension 2 k2 . The set of the Pauli operators on n qubits in S D that consist of only Zs and Is is referred to as S Z D . Construct stabilizer generators S C in the same manner by using C.
Take an arbitrary 2k 1 − n qubit state |ϕ , which is to be encoded. By using an encoder for the CSS code of parameters [[n, 2k 1 −n]] defined by S C , the state |ϕ is encoded into n qubit state |ϕ enc = i α i |v i , where each v i is an n-dimensional vector with the orthogonal basis being C ⊥ + r i (x) | r i (x) ∈ R . Let U g be the unitary operator that adds the coefficient vector g of g(x). By applying U g , we have: Take a pair of nonnegative integers a l , a r that satisfy a l + a r < k 2 − k 1 . Using a l + a r ancilla qubits and CNOT gates, we take this state to an n + a l + a r qubit state as follows: where w 1 i and w 2 i are the last a l and the first a r portions of the vector v i + g respectively. The resulting state |ψ enc = i α i w 1 i , v i + g, w 2 i then goes through a noisy quantum channel.

D. Error correction and block synchronization
Gather n + a l + a r consecutive qubits G = (q 0 , . . . , q n+a l +ar −1 ). We assume the situation where correct block synchronization means that G is exactly the qubits of |ψ enc , but G can be misaligned by a qubits to the right, where −a l ≤ a ≤ a r .
Let P = (p 0 , . . . , p n+a l +ar −1 ) be the n + a l + a r qubits of the encoded state. If a = 0, then P = G. Define G m = (q a l , . . . , q a l +n−1 ). By assumption, G m = (p a l +a , . . . , p a l +n−1+a ). Let n-fold tensor product E of linear combinations of the Pauli matrices be the errors that occurred on P .
We first outline the bit error correction procedure on the window G m . Synchronization is recovered after making G m free from bit errors. The bit errors outside of G m are then corrected. The phase errors on qubits will be treated at the final step after reversing the extension process.

Bit error correction on the initial window
We correct bit errors that occurred on qubits in G m in the same manner as the separate two-step error cor-rection procedure for a CSS code. Since C ⊂ D, the vector space spanned by the orthogonal basis stabilized by S D contains V g as a subspace. Hence, through a unitary transformation using S Z D , we can obtain the error syndrome in the same manner as when detecting errors with the CSS code defined by S D as follows: where |χ is the n − k 2 qubit syndrome by S Z D . If E introduced at most ⌊ d2−1 2 ⌋ bit errors on qubits in G m , these quantum errors are detected and then corrected by applying the X operators if necessary.
More formally, rewrite the original encoded state where c i correspond to the window misaligned by a qubits to the right, which can be obtained by cyclically shifting v i + g. Hence, the binary vectors l i , and r i are of lengths a l + a and a r − a respectively. Without loss of generality, we consider E the discretized bit errors and phase errors on the n + a l + a r qubits of |ψ enc . Let e b be the (n + a l + a r )-dimensional binary error vector such that i ∈ supp(e b ) if and only if a bit error occurred on qubit p i . In other words, the positions of 1s in e b represent which qubits are bitwise flipped. Define the phase error vector e p in the same way for the phase errors that occurred on |ψ enc . Then, the transformation due to the noisy quantum channel that introduced quantum error E is Write the bit error vector as e b = (e b l , e b c , e b r ), where e b l , e b c , and e b r are the first a l + a, next n, and last a r − a bits of e b respectively. Recall that H D is the full-rank parity-check matrix of D corresponding to the stabilizer generators. We perform the following unitary transformation using S Z D with n − k 2 ancilla qubits: Because H D is a parity-check matrix of D, measuring the ancilla gives the error syndrome in the same manner as the corresponding classical linear code does. Thus, as in the standard bit error correction procedure for a CSS code, if we assume that E introduced at most ⌊ d2−1 2 ⌋ bit errors on qubits in G m , applying X operators to qubits specified by the error syndrome H D e b c takes the encoded sate with errors to where E ′ represents the partially corrected quantum errors.

Synchronization recovery
We perform synchronization recovery by exploiting the bit-error-free G m we just obtained. Recall that all codewords of C ⊥ and r i (x) ∈ R belong to C, and hence to D as well. Because g(x) is the generator of D, it divides any polynomial of the form s(x) + r i (x) + g(x) over for some polynomials i 0 (x) and i 1 (x) of degree less than k 1 , the quotient is of the form j(x)f (x) + 1 for some polynomial j(x). Dividing the quotient by f (x) gives 1 as the remainder. Note that g(x) is a monic polynomial of degree n − k 2 that divides x n − 1, where k 2 is strictly larger than ⌈ n 2 ⌉. Let i be an integer satisfying 1 ≤ i ≤ ⌈ n 2 ⌉ ≤ k 2 − 1. Then ).
Hence, we have |Orb(g(x))| ≥ k 2 > ⌈ n 2 ⌉. Because |Orb(g(x))| must divide n, we have |Orb(g(x))| = n. Thus, applying the same two-step division procedure to any polynomial appearing as a state in cyclically shifted V g by a qubits gives x a (mod f (x)) as the remainder. By assumption, we have and −a l ≤ a ≤ a r . Thus, the remainder x a (mod f (x)) is unique to each possible value of a.
Recall that every state in V g is of the form C ⊥ + r i (x) + g(x) . Because G m contains no bit errors, the basis states of the corresponding portion in E ′ |ψ enc are the cyclically shifted coefficient vectors of the correct polynomials. Let Dq t(x) and Dr t(x) be the polynomial division operations on n qubits that give the quotient and remainder respectively through quantum shift registers defined by a polynomial t(x) of degree less than n [21] (see also [22] for an alternative way to implement quantum shift registers). Let Q = I ⊗a l +a Dq g(x) I ⊗ar−a and R = I ⊗n+a l +ar Dr f (x) , so that the two represent applying Dq g(x) to the window and Dr f (x) to the ancilla qubits of Dq g(x) that contain the calculated quotient. These operations give the syndrome for the synchronization error as for the CSS code based on the dual-containing cyclic code C: → E ′′′ |ϕ enc |H C (e p c + (0, e p l ) + (e p r , 0)) , where H C is a full-rank parity-check matrix of C and E ′′′ is the phase error operator on |ϕ enc that represents the effect of e p c + (0, e p l ) + (e p r , 0). Applying Z operators on the qubits specified by the syndrome completes the error correction procedure.

Proof of Theorem 1 and example codes
We are now able to prove Theorem 1. Proof of Theorem 1. Take a dual-containing cyclic [n, k 1 , d 1 ] code C that is contained in a cyclic [n, k 2 , d 2 ] code, where k 1 < k 2 . Encode 2k 1 − n logical qubits into n + a l + a r physical qubits as described above. The error correction and synchronization recovery procedures described above correct misalignment by a qubits to the right as long as a lies in the range −a l ≤ a ≤ a r and correct up to ⌊ d1−1 2 ⌋ phase errors on the n + a l + a r qubits and up to ⌊ d2−1 2 ⌋ bit errors on any consecutive n qubits. The final decoding step is completed by reducing the state |ϕ enc = i α i |v i to the original state |ϕ by a decoding circuit of the CSS code based on the dualcontaining cyclic code C. Thus, the scheme is a quantum synchronizable (a l , a r )-[[n + a l + a r , 2k 1 − n]] code with the desired error correction capability.
To take full advantage of Theorem 1, we need dualcontaining cyclic codes that achieve large minimum distance and contain dual-containing cyclic codes of smaller dimension. A class of the well-known Bose-Chaudhuri-Hocquenghem (BCH) codes [18] gives such classical codes. The dual-containing properties of BCH codes have been thoroughly investigated in [23,24]. The following is an infinite series of quantum synchronizable errorcorrecting codes based on a class of such codes, called the primitive, narrow-sense BCH codes (see [18] for the definition and basic properties of primitive, narrow-sense BCH codes): Corollary 2 Let n, d 1 , and d 2 be odd integers satisfying and any pair of nonnegative integers a l , a r satisfying a l + a r < m(d1−d2) 2 there exists a quantum synchronizable (a l , a r )-[[n + a l + a r , n − m(d 2 − 1)]] code that corrects up to phase errors on the n + a l + a r qubits and up to bit errors on any consecutive n qubits.
Proof. Let n, d 1 , and d 2 be integers satisfying the condition given in the statement. Let D be a primitive narrow-sense BCH code of length n and designed distance d 2 such that 3 ≤ d 2 < 2 ⌈ m 2 ⌉ − 1. Construct a primitive narrow-sense BCH code C by joining one or more cyclotomic cosets, so that its designed distance d 1 is larger than d 2 but smaller than or equal to 2 ⌈ m 2 ⌉ − 1. The dimensions of C and D are n − m(d1−1) 2 and n − m(d2−1) 2 respectively. D contains C, and the two cyclic codes are both dual-containing (see [23]), forming the desired quantum synchronizable codes.

IV. CONCLUSION
We developed a coding scheme that seamlessly integrates block synchronization and quantum error correction. A close relation is found between quantum synchronizable error-correcting codes and pairs of cyclic codes with special properties. Through this relation, the well-known BCH codes were shown to generate desirable quantum codes for block synchronization.
In classical communications, a unified method for synchronization and error correction can reduce implementation complexity [25]. A similar method using cyclic codes has also been proposed recently in the classical domain for simple implementation of asynchronous code division multiple access (CDMA) systems with random delays [26]. We hope that our seamlessly unified solution to block synchronization and quantum error correction may help simplify requirements on hardware and open up new possibilities of quantum computation and quantum communication such as transmission of a large amount of consecutive quantum information blocks with little aid from classical communications.
One potential weakness of the approach presented in this paper is that our quantum synchronizable codes of length n + a l + a r may face a larger number of quantum errors than the underlying standard CSS codes of length n would because of their extended lengths. For instance, in a scenario where the receiver missed the first several qubits, the window may be suffering from severe quantum errors which may not be correctable. Phase error correction requires particular attention in this regard because while the current scheme takes advantage of the subcode C, which typically has a larger minimum distance than D for bit errors, the error correction scheme for phase errors is expected to handle all phase errors at once unlike the bit error correction procedure. While the ability to recover from misalignment is highly valuable because even the slightest synchronization error is fatal to information transmission, these weaknesses should be noted and are worthy of further investigation. One aspect we may be able to improve is the maximum magnitude of a correctable synchronization error. The scheme presented in this paper relies on the uniqueness of the syndrome for each possible combination of the magnitude and direction. While the remainder x a (mod f (x)) after the two-step division procedure for synchronization recovery is certainly unique if we limit a l +a r to be less than deg(f (x)), this may be overly conservative in a sense. In fact, there are 2 deg(f (x)) possible polynomials of degree deg(f (x)) or smaller while we only need at most n distinct synchronization error syndromes even if we extend a CSS code of length n to a full 2n qubit code by copying all n qubits with CNOT gates. While our scheme does not appear to allow a better general bound on the maximum correctable magnitude in a simple form without a deeper observation and careful modification, it is plausible that a sophisticate treatment of syndromes may yield quantum synchronizable codes with better synchronization error tolerance than is proved in this paper.
Finally, while we have focused on binary dualcontaining cyclic codes, it is certainly of interest to look into more general approaches to quantum error correction such as orthogonal pairs of cyclic codes that are not dual-containing and the quantum error-correcting codes from additive codes over F 4 found in [27]. While CSS codes and similar quantum error-correcting codes based on classical cyclic codes that admit decoding through quantum shift registers have not been studied very well in the literature, there are some examples that have very similar structures such as quantum Reed-Solomon codes [28] (see also [21] for a possible decoding scheme for this type of quantum error-correcting code through quantum shift registers). A further look into these types of quantum cyclic code would be of interest.