Efficient code for relativistic quantum summoning

Summoning retrieves quantum information, prepared somewhere in spacetime, at another specified point in spacetime, but this task is limited by the quantum no-cloning principle and the speed-of-light bound. We develop a thorough mathematical framework for summoning quantum information in a relativistic system and formulate a quantum summoning protocol for any valid configuration of causal diamonds in spacetime. For single-qubit summoning, we present a protocol based on a Calderbank–Shor–Steane code that decreases the space complexity for encoding by a factor of two compared to the previous best result and reduces the gate complexity from scaling as the cube to the square of the number of causal diamonds. Our protocol includes decoding whose gate complexity scales linearly with the number of causal diamonds. Our thorough framework for quantum summoning enables full specification of the protocol, including spatial and temporal implementation and costs, which enables quantum summoning to be a well posed protocol for relativistic quantum communication purposes.


I. INTRODUCTION
Quantum summoning is the task of encoding and transmitting quantum information to a configuration of spacetime causal diamonds such that the quantum information can be reconstructed in any one of these causal diamonds [1][2][3][4]. Quantum summoning cannot be guaranteed to work for every configuration of causal diamonds because quantum information cannot be copied [5][6][7][8] or transmitted superluminally [6]. Summoning is only possible for a configuration of causal diamonds if every pair of diamonds is causally related, where two diamonds are causally related if the earliest point of one can communicate with the latest point of the other [2]. Our aim is to construct efficient protocols for summoning quantum information in any configuration of N pairwise-related causal diamonds.
A variety of work has been done on summoning ever since Kent introduced this task and presented a nosummoning theorem [1]. Hayden and May [2] showed that quantum summoning can be reduced to the primitives of quantum secret sharing [9][10][11] and teleportation [12,13]. They exploited a codeword-stabilized (CWS) quantum code [14] to design a summoning protocol that is efficient in the sense that the number of qubits Q used by the code is polynomial in N . Hayden et al. [3] proposed a continuous-variable version of summoning and an efficient protocol to perform this task, as well as showing that optical circuits can be used to realize summoning experimentally. In 2016, Adlam and Kent proposed a summoning task with multiple summonses and provided a protocol, which employs teleportation, to accomplish this task for the configuration being an ordered set of causal diamonds [4].
Our protocol for summoning quantum information uses a Calderbank-Shor-Steane (CSS) code [15,16] that encodes one qubit into Ñ 2 physical qubits, with the restriction thatÑ is even. We calculate that this CSS code distanceÑ 2 , and this code is constructed from the relation between graphs and linear algebra [17,18]. Our code is a qubit version of the homological continuousvariable quantum error correcting code [3] and corrects erasure errors that occur in summoning.
We provide a procedure to construct the encoding and decoding circuits for our CSS code for any even positive integerÑ . The number of qubits Q used by our protocol is reduced by a factor of two compared to the previous best [2], and the number of quantum gates G is reduced from O N 3 [2] to O N 2 . Our decoding procedure has gate complexity O(N ). Our results are significant in that we complete the quantum summoning protocol [1][2][3] by providing both encoding and decoding schemes, explain how to utilize quantum error correction for summoning, analyze quantum resources, and demonstrate improved efficiency for our protocol.
Our paper is organized as follows. Section II reviews the background knowledge regarding summoning, quantum error correction and algebraic graph theory. Section III provides the mathematical definition of summoning. In section IV, we study a protocol for summoning using a CSS code, including the encoding and the decoding methods, and the resource analysis of the CSS code and the CWS code. Sections V and VI give the discussion and the conclusion, respectively. arXiv:1711.10594v3 [quant-ph] 19 Jul 2018

II. BACKGROUND
Here we explain the quantum information processing task of summoning and the conditions for the configurations to make summoning feasible [1][2][3]. Then we give the background knowledge on stabilizer quantum error correcting codes [21], especially CSS codes [15,16]. We introduce the relation between graphs and binary vectors [17], which is useful for the construction of the CSS stabilizer code. Finally, we briefly review the CWS code [14] used by Hayden and May to summon quantum information [2].

A. Summoning
Summoning is an information processing task involving Alice and Bob [1][2][3]. Bob's role is to provide the quantum information to Alice and to designate where the quantum information is to be summoned and Alice's role is to summon quantum information at the designated spacetime location. Associated to each request point y is a reveal point z y that is in the causal future of y. The intersection of the future light cone of y with the past light cone of z y is called a causal diamond, expressed as . We label causal diamonds and show a label i in the diamond as i . Besides the request and reveal points, Alice and Bob also agree upon a starting point s, where Bob provides the quantum information to Alice.
Alice and Bob can arrange their agents at various points in spacetime prior to the start of summoning [3]. Bob designates one agent to be the referee who sends quantum information to point s and classical information to all the request points. Alice designates one agent to be the starting agent S, who is situated at point s, and she delegates agents to each request and reveal point. We label the agent at point x by A x . Figure 1 shows an example of Alice's and Bob's agents arranged in spacetime.
When summoning starts, the referee prepares a quantum state where H is a finite d-dimensional Hilbert space [2], and transmits |ψ to the starting agent. Alice and all her agents do not have any knowledge of |ψ . The referee randomly chooses one request point, say y, and sends the request only to A y . Then Alice's task is to present the quantum state |ψ at the corresponding reveal point z y , by her agents' collaboration.

Given a set of causal diamonds
, summoning might be infeasible [1] due to the restrictions of both the no-cloning theorem [5][6][7][8] and no superluminal communication [6]. Summoning is possible if and only if the following two conditions are satisfied [2].
C1 All reveal points are in the causal future of s. We call a set of causal diamonds satisfying these two conditions a "valid configuration" for summoning. We represent a configuration of causal diamonds by a graph G as follows [2,3]. We assign each causal diamond to a vertex and use the label of the causal diamond to label the vertex. If two causal diamonds are causally related, an edge e is inserted between the two corresponding vertices in G. A valid configuration of N causal diamonds is represented by an N -vertex complete graph denoted K N , for which each pair of vertices is connected by an edge [17].
In Fig. 1, we present an example of using quantum secret sharing [9][10][11] to summon quantum information [2]. After receiving a qubit |ψ , the starting agent encodes |ψ into three qutrits [9] and distributes the three qutrits to the three request agents. If A yi (i = 1, 2, or 3) receives the request, then the request agent sends her qutrit to the reveal point Otherwise, she sends her qutrit to the reveal point z (i−1) mod 3 . In such a way, no matter which request agent receives the request, the associated reveal agent receives two qutrits to retrieve the original qubit |ψ .

B. Stabilizer codes
In this subsection, we begin by introducing the Pauli group and the representation of Pauli operators using binary vectors. We explain the parameters characterizing a quantum error correcting code and the definition of erasure errors. Then we explain stabilizer codes [21], specially CSS codes [15,16]. Finally, we show the encoding of a stabilizer code.
An n-qubit Pauli group [22] is where The Pauli group module sign is isomorphic to a cartesian product of binary vector spaces according to where Two Pauli operators represented as binary vectors, u v and u v , mutually commute if and only if [22] u · v + v · u = 0, where · is the indefinite inner product Otherwise, these two Pauli operators anti-commute with each other. In quantum error correcting codes, [[n, k, d]] denotes a quantum code, where k qubits are encoded into n qubits, and d is the distance of the code [22]. Given a Pauli operator P ∈ G n , the weight of P is the number of nonidentity single-qubit Pauli operators, i.e., X, Y and Z in the tensor product P . The distance of a quantum error correcting code is the minimum weight of a Pauli operator P such that where |i and |j are basis elements of the code, C(P ) is a constant depending on P , and δ ij is the Kronecker delta function. When transmitting a block of n qubits, if t qubits (t < n) are lost or never received, while the other n − t qubits are undamaged, then the errors at these t qubits are called erasure errors [23]. A stabilizer code [21] is the simultaneous eigenspace of all the elements of an Abelian subgroup S of G n with eigenvalue one. A generator set of S is a set of independent elements in S such that every element of S can be expressed as a product of the elements in this generator set. An [[n, k, d]] stabilizer code has n − k independent stabilizer generators, each of which can be represented by a 2n-dimensional binary vector. The [[n, k, d]] stabilizer code is characterized by an (n − k) × 2n stabilizer generator matrix, where each row represents a stabilizer generator. Now we introduce CSS codes, which are a type of stabilizer codes. A CSS code [15,16] is specified by two classical linear codes C 1 and C 2 , where C 2 is a subcode of C 1 , i.e., Each basis element of a CSS code corresponds to a coset [24] of C 2 in C 1 , where the basis element is an equally weighted superposition of all the codewords in the coset. A CSS code is a stabilizer code whose stabilizer generators are either tensor products of X operators and identities, or tensor products of Z operators and identities [21]. Hence, the CSS stabilizer code is characterized by an (n − k) × 2n stabilizer generator matrix where H Z and H X are two matrices, and the 0s are appropriately sized zero matrices.
Here we explain the encoding of a stabilizer code with stabilizer S. The Pauli operators that preserve the stabilizer code space but act nontrivially on the encoded state are the logical Pauli operators on the encoded state [21]. The logical Pauli operators commute with all stabilizers in S but lie outside S.
For an [[n, 1, d]] stabilizer code with stabilizer S, we denoteZ andX as the logical Z and logical X operators on an n-qubit encoded state. Supposē and are n − 1 independent stabilizer generators of S. The encoded logical states are [21] |0 L := and Equations (14) and (15) indicate how to encode one qubit by a stabilizer code.
We have discussed quantum error correction, especially stabilizer codes in this subsection. Next we study the close relation between a graph and a binary vector, which provides a powerful tool to construct the CSS stabilizer code.

C. Graphs and linear algebra
In this subsection, we begin by defining graphs and the binary linear space. After explaining these two concepts, we describe an isomorphism from sets of edges of an n-vertex graph to binary vectors with length n 2 [17]. Our approach is inspired by homology theory to construct quantum error correcting codes [3,18]. Finally, we present the examples of triangle graphs and star graphs.
A graph [17] G := (V, E) comprises a set of vertices V and a set of edges One example of a graph is the n-vertex complete graph, K n . To explain the binary linear space, we introduce GF (2), which is the smallest finite field containing two elements {0, 1}, together with addition and multiplication operations [25]. The linear space [24] over field GF (2), denoted by Z m 2 , is a set {0, 1} m , together with vector addition, and scalar multiplication, 1 Next we explain the relation between an edge set E of a graph G and a binary vector with length |V | 2 , where |V | is the cardinality of V .
Given K n = (V K , E K ), the power set of E K , which is the set of all the subsets of E K , forms a binary linear space E [17]. The power set of E K is denoted 2 E K . For U , U ∈ 2 E K , the addition of U and U amounts to the symmetric difference of U and U , The empty set Ø is the zero element and For i and j , an edge e ij is a unit vector in E , and e ji = e ij because we are dealing with undirected graphs. The set of edges 1 Note we use · for the scalar multiplication only in Eq. (19) and Table I. After this subsection, we use · only for the indefinite inner product.
forms an orthonormal basis of E . As n 2 edges exist in K n , Now we show that E is isomorphic to Z ( n 2 ) 2 [17]. Given any U ∈ E , an isomorphism is where are the coefficients of U with respect to the basis in Eq. (22). The isomorphic mappings of the vector addition and the scalar multiplication are shown in Table I.
Here we introduce two types of n 2 -dimensional binary vectors and two linear subspaces spanned by these two types of vectors as examples of the isomorphism (24).
where e ij is the unit vector I G (e ij ). From the isomorphism (24), these two types of vectors can be represented by two different types of graphs. T ijk is represented by a triangle graph connecting vertices and A j is represented by a star graph with vertex j connected to every other vertex. We construct the linear space spanned by n − 1 linearly independent {A j }, and the orthogonal linear space 1 are represented by Eulerian cycles (graph cycles that use each edge exactly once) [17]. Meanwhile, C 1 comprises vectors orthogonal to all vectors in C ⊥ 1 [17], i.e., We introduce an (n − 2)-dimensional linear subspace of C 1 (30) C 2 together with C 1 specifies the CSS code for summoning in Subsec. IV B. Figure 2(a), (b) and (c) depict the graphs representing bases of linear spaces C ⊥ 1 , C 1 and C 2 respectively for n = 4.
This subsection has shown that the power set of the edge set of an n-vertex complete graph forms a binary linear space, isomorphic to Z ( n 2 ) 2 . Hence, we have constructed a graph representation of any n 2 -binary vector. The examples given in this subsection are useful to construct the CSS code for summoning.

D. The CWS code for summoning
In this subsection, we first introduce CWS codes [14], then explain the graph-state formalism of CWS codes. Finally we discuss the CWS code used by Hayden and May for quantum summoning [2]. In Subsec. IV D, we study the gate complexity of the encoding of the CWS code for summoning and compare it with the CSS code. Each vertex of G CWS is labeled by (j, (j, k)) for 1 ≤ j, k ≤ 4 and k = j. Each (j, (j, k)) is adjacent to (k, (j, k)) and (j, (j, l)), where 1 ≤ l ≤ 4 and l = j or k.
An ((n, k)) CWS code [14] encodes a k-dimensional Hilbert space to n qubits. This CWS code is specified by a word stabilizer, which is a 2 n -element Abelian subgroup S of G n , and a set of k word operators, which are n-qubit Pauli operators The word stabilizer S specifies a unique |ψ S such that ∀M ∈ S, The CWS code is spanned by the basis Under local Clifford operations, any CWS code is equivalent to its standard form [14], whose word stabilizer is a graph-state stabilizer [26], and whose word operators contain only Z operators and identities. Thus, the stabilized state |ψ S of a CWS code in its standard form is a graph state. Given a graph G = (V, E), the associated graph state is [26] where CZ (i j) is the controlled-Z gate with control qubit i and target qubit j, and H is the Hadamard gate.
Hayden and May propose a 2 N 2 , 2 CWS code to summon a qubit in N causal diamonds [2]. This 2 N 2 , 2 CWS code is specified by a graph-state stabilizer represented by a graph G CWS and two word operators Given an N -vertex complete graph K N = {V K , E K }, G CWS is the line graph [17] of G := {V , E }, where and Figure 3 presents G CWS for N = 4. This CWS code can be used to summon one qubit in four causal diamonds [2] by employing twelve qubits. This section has introduced quantum summoning as a quantum information processing task in spacetime and explained the conditions on the configurations to make quantum summoning feasible. We have briefly reviewed the background knowledge on quantum error correction, especially stabilizer codes and CSS codes, which are used for quantum summoning in this paper. We have explained the connection between graphs and binary vectors, which is useful for the construction of the CSS code for summoning. Finally, we have reviewed the CWS code used for quantum summoning [2], with which we compare our CSS code in Subsec. IV D.

III. MATHEMATICAL DEFINITION OF SUMMONING
In this section, we mathematically define both classical and quantum summoning. We begin by formalizing the notions of past and future light cones and causal diamonds. We than establish notations for a configuration of causal diamonds and the sets of request and reveal points. Subsequently, we give a careful definition of both classical and quantum summoning, and when these tasks are trivial.
Each spacetime point is x ∈ M, where M denotes Minkowski spacetime [27]. The future light cone for x is where w x indicates that information can be sent from x to w. The past light cone for x is where w ≺ x indicates that information can be received at x from w. A causal diamond for a pair of points A configuration of causal diamonds is and N := |C |. Two causal diamonds i and j are causally related if and only if ∃ x ∈ i , ∃ w ∈ j such that either x ∈ fut(w), or x ∈ pas(w). The set of request points is and the set of reveal points is A starting point is s ∈ M such that ∀ z ∈ REV, z ∈ fut(s), where there is a starting agent S. We now formalize Kent's classical summoning protocol [1] by making each object mathematically well defined. Given starting agent S at s ∈ M, request agents and corresponding reveal agents and S possessing n-bit string m ∈ {0, 1} n , summoning is the task of delivering m to any agent in REVAG given arbitrary external selection of some y ∈ REQ, which is only revealed at spacetime point y.

Remark 1.
Classical summoning is trivial because S broadcasts m to all z ∈ REV [1].
The notion of quantum summoning [1,2] builds on the concept of classical summoning, which we formalize as follows. Given a starting agent S, REQAG and REVAG, and S possessing quantum information |Ψ ∈ H ⊗n 2 (45) (with S possibly oblivious to |Ψ ), summoning is the task of delivering |Ψ to any agent in REVAG given arbitrary external selection of some y ∈ REQ, which is only revealed at spacetime point y.

Remark 2.
Summoning is trivial if S has a classical description of |Ψ because S broadcasts this description such that all agents in REVAG receive and can reconstruct |Ψ .
Remark 3. Quantum summoning is trivial if there is a causal curve, which starts from s and runs sequentially through all i ∈ C in any order. The protocol is trivial in this case because quantum information can simply be sent along this causal curve. When quantum information arrives at j , A yj decides whether to send it to z j or to send it to the next causal diamond depending on whether she receives the request or not.

IV. SUMMONING BY QUANTUM ERROR CORRECTION
Here we present a protocol for Alice to summon quantum information. We specify the actions that the starting agent and each of the request and reveal agents perform to fulfill any summoning request (Subsec. IV A). For any valid configuration of causal diamonds, we propose a CSS code for the protocol of quantum summoning (Subsec. IV B). The encoding and decoding circuits of the CSS code are provided (Subsec. IV C). We show that the CSS code consumes fewer quantum resources than the CWS code [2] (Subsec. IV D).

A. Protocol
Here we propose a protocol using the CSS code (1) for summoning one qubit in any valid spacetime configuration. This CSS code assigns one qubit to each edge of the complete graph KÑ ; hence, the number of qubits used by the protocol is for N andÑ related according to Eq. (1). For a spacetime configuration with an even number N of causal diamonds,Ñ := N and S employs the CSS code (1) to encode a qubit, into Q (46) qubits and assigns each qubit to an edge of the complete graph KÑ . The qubit assigned to the edge e ij is called q ij , where e ij denotes the edge connecting i to j for i, j ∈ [N ] and i = j,. S sends q ij to A yi if and to A yj if If A yi receives the summoning request, she sends all the qubits in her possession to A zi . Otherwise, she sends each qubit q ij in her possession to A zj . As each vertex is adjacent to N − 1 edges, any reveal agent, who receives the summoning request, receives N − 1 qubits. Later, we prove that ∀ r ∈ [N ] := (1 2 · · · N ), the qubits can be used to decode |ψ perfectly. Fig. (4) shows how the qubits are assigned to the request agents for a configuration of four causal diamonds. In a configuration of an odd number of causal diamonds,Ñ := N + 1.
S introduces one more vertex N+1 to obtain graph K N +1 . This new vertex can be seen as ficticious causal diamond causally related with every causal diamond, but the summoning request is never sent to this causal diamond. Then S employs the CSS code (1), which encodes |ψ into N +1 2 qubits. As before, S sends each qubit q ij , where i, j ∈ [N ], to A yi if and to A yj if S sends each additional qubit q j N +1 to reveal agent A zj . As in the even case, if A yi receives the summoning request, A yi sends all the qubits in her possession to A zi . Otherwise, she sends each qubit q ij in her possession to A zj . Any reveal agent who receives the summoning request, ultimately receives N qubits to decode |ψ . For any r ∈ [N + 1], the qubits can be used to decode |ψ perfectly. This protocol can also be used to accomplish a variant of the summoning task [4]. In this modified task, the set of causal diamonds are causally ordered and the request may be sent to multiple request agents but only one of them needs to comply with the summon. If the causal diamonds are causally ordered, then in the subset of request agents to whom the requests are sent, let A yr be the earliest request agent according to the causal order of the diamonds. By following the above protocol, the reveal agent A zr receives the N − 1 qubits if N is even and the N qubits if N is odd. Hence, A zr can decode the state |ψ . This subsection has explained our protocol for quantum summoning. Subsection IV B provides the detail of the CSS code (1) used in our protocol.

B. The CSS code
In this subsection, we propose a stabilizer code with each qubit assigned to an edge of KÑ . We show that it is an Ñ 2 , 1,Ñ 2 CSS code, which can be used to summon a qubit by following the protocol in Subsec. IV A.  stabilizer generator matrix

Agent Assigned qubits
where 0 is an The stabilizer generator matrix (56) is analogous to the stabilizer generator matrix of the homological continuous-variable quantum error correcting code [3]. By changing −1 to 1 in the stabilizer generator matrix of the continuous-variable code, one obtains the generator matrix (56) from the generator matrix of the continuousvariable code. In continuous-variable codes, ±1 in the generator matrix represents the phase-space displacement operators e ±iX or e ±iP , whereX andP are quadrature operators [28,29]. On the other hand, in the qubit code, 1 in the generator matrix represent Pauli operators Z or X.
To prove this theorem, we prove the following three lemmas.
Lemma 2. HÑ (56) is a stabilizer generator matrix of a CSS code, which encodes one qubit into Ñ 2 qubits. Proof. From Eqs. (27) and (28), for any j, k, l such that 2 ≤ j < k ≤Ñ and 2 ≤ l ≤Ñ −1 Using Eq. (8), we know that all the stabilizer generators in HÑ (56) commute with each other, thereby generating an Abelian subgroup S of G (Ñ 2 ) . There are Ñ 2 − 1 independent stabilizer generators, so this stabilizer code encodes one qubit into Ñ 2 qubits. The first Ñ −1 2 stabilizer generators contain only Z operators and identities and the otherÑ − 2 stabilizer generators contain only X operators and identities. Thus, the stabilizer code is a CSS code.
In HÑ , the vectors representing the Z-type stabilizers and the X-type stabilizers span C ⊥ 1 (28) and C 2 (30) for n =Ñ respectively. Thus, the CSS code in Theorem 1 is specified by the linear codes C 1 (27) and C 2 (30) for n =Ñ . Now we show that by assigning each of the Ñ 2 physical qubits to an edge in KÑ , this CSS code can correct the erasure errors at those qubits, which are not connected to vertex r , for any r ∈ Ñ . Hence, by following the protocol of quantum summoning in Subsec. IV A, no matter which A yr receives the request, the associated reveal agent A zr can decode the original state |ψ from herÑ − 1 qubits in Eq. (50) or Eq. (54). Lemma 3. For any r ∈ Ñ , the CSS code in Theorem 1 can correct erasure errors at qubits q ij for i, j ∈ Ñ \{r}.
The proof of Lemma 3 is in Appendix A. The proof is a modified version of that for the continuous-variable code [3] with the infinite-dimensional field R replaced by the finite-dimensional field Z 2 . One side effect of this modification is thatÑ has to be even. Lemma 3 is no longer true ifÑ is odd. To see this, we consider an example of a three-qubit code with stabilizer generators {ZZZ, IXX}. If r = 3, this code should correct any Pauli error at q 12 . This is obviously false, because the Pauli error at q 12 , ZII, commutes with both stabilizer generators but does not lie in the stabilizer group. Now we find the distance of the CSS code, which is an important parameter characterizing the capability of the code to detect and correct errors. This subsection has specified the CSS code (1) by its stabilizer generator matrix (56). We have shown the erasure errors that the CSS code, can correct and the distance of the CSS code. In next subsection, we explain how to encode and decode this CSS code.

C. Encoding and decoding
In last subsection, we have shown that the encoding of our CSS code employs O(N 2 ) qubits while the decoding uses only O(N ) qubits. In this subsection, we present systematic methods to construct encoding and decoding circuits for our CSS code. The encoding method used here follows the standard method of encoding stabilizer codes [21], discussed in Subsec. II B. Our decoding method differs from the stabilizer code decoding method because it only corrects erasure errors, which occur in summoning. We also calculate the gate complexity of both the encoding and the decoding circuits. It is shown that G in the encoding is O(N 2 ) and G in the decoding is O(N ).
To build the encoding circuit of this CSS code, we introduce logical operations on the encoded state. By using the vector representation (6), the logical operations are defined asX  From A 1 · A 1 = 1 and Eq. (8),X andZ anti-commute with each other.
We choose which is an eigenstate ofZ with eigenvalue one. To encode |ψ (47), using Eqs. (14) and (15), and the fact that Z-type stabilizers act trivially on |ψ 0 , we obtain the encoded state FIG. 6: The encoding circuit of the CSS code comprising Hadamard gates and CNOT gates wheñ N = 4. The inputs of this circuit are |ψ ⊗ |00000 and the outputs of this circuit are the qubits assigned to each edge of the complete graph K 4 shown in Fig. 4(b). where and (A 1 + A j ) i and (A 1 ) i are the i-th entries of vectors A 1 + A j and A 1 respectively. S applies CNOT gates as in Fig. 5(a) to the product state to obtain Then S implements each operation where 1 ≤ j ≤Ñ − 2, by using CNOT gates and a Hadamard gate as in Fig. 5(b). Finally, S obtains the encoded state (61). Figure 6 presents an example of the encoding circuit forÑ = 4. The number of CNOT gates in Fig. 5(a) is O(N ). In Fig. 5(b), the number of CNOT gates is O(N ) and the number of Hadamard gate is one. As the circuit in Fig. 5(a) is only applied once and the circuit in The decoding scheme is explained in the following. Suppose the request is sent to y r . Reveal agent A zr cannot decode by measuring the syndromes as she has onlyÑ − 1 qubits. The encoded state (61) is an equally weighted superposition of the codewords given . 7: One example of the decoding circuit comprising CNOT gates and measurements of Z operators for N = 4. The inputs of the circuit are three physical qubits q 14 , q 24 and q 34 and two ancillary qubits |00 . The measurement outcomes on the two ancillary qubits are +1 and −1, based on which two CNOT gates are applied with the third qubit as the control qubit and the first two qubits as the target qubits. The third output qubit is the original qubit |ψ .
in Eqs. (C1) and (C2) (see Appendix C). After tracing out the lost qubits, the reduced state ρ r (C12) becomes a mixture of the codewords. To decode the original state |ψ from theÑ − 1 qubits with reduced density matrix ρ r , reveal agent A zr measures the set of mutually commutative Hermitian operators where Z q rk represents the Z operator on the qubit q rk . After applying the projective measurements, the reduced state is projected onto one codeword, becoming a pure state (see Appendix C). According to the measurement outcomes, by applying N − 2 CNOT gates with one control qubit and distinct target qubits, A zr obtains the original state |ψ at the control qubit. Fig. 7 presents an example of the decoding circuit when the request is received at 4 . In decoding, G ∈ O(N ) and the number of single-qubit measurements is also O(N ).

D. Comparison with the CWS code
Now we compare the quantum resources required by our CSS code with Hayden and May's CWS code. To investigate the complexity of the encoding of the CWS code, we need to know the complexity of preparing graph state |G CWS . From Eq. (33), we know that the number of controlled-Z gates and Hadamard gates in preparing a graph state equals to the number of edges and vertices in the graph, respectively. The numbers of edges and vertices in G CWS are Our protocol employs a CSS code to summon quantum information in any valid configuration. The CSS code can correct the erasure errors that occur in the quantum summoning task. The encoding and the decoding methods for this CSS code have been presented. Finally, we have compared the complexity of the encoding of the CSS code with the encoding of the CWS code and found that our CSS code is more efficient.

V. DISCUSSION
We have presented a protocol to summon quantum information efficiently in any valid configuration of causal diamonds. Central to our protocol is a CSS code that encodes one logical qubit into O(N 2 ) physical qubits, where each physical qubit is assigned to an edge of a complete graph whose vertices correspond to causal diamonds. This code is a qubit version of the homological continuous-variable quantum error correcting code [3]. The CSS code is designed using the fact that the power set of edges of a complete graph can be cast as a vector space. The stabilizer generators of the CSS code correspond to triangle graphs and sums of star graphs.
The properties of these graphs are used to show that the logical qubit can be decoded from the subset of physical qubits that are assigned to edges adjacent to any vertex. In order to employ this code for summoning, the physical qubits are sent to the request points in such a way that the past of every reveal point contains enough physical qubits to decode the original qubit. Our protocol design, similar to one used previously [3], ensures that whenever a request agent receives the request the associated reveal agent receives all physical qubits required to decode the original qubit.
We also present procedures to design the encoding and decoding circuits for the CSS code. We show that our protocol is less resource-intensive than the protocol based on the CWS code [2] which uses circuits that are O(N 2 ) wide and O(N 3 ) deep. The circuits for the CSS code have width that is also O(N 2 ) but half that of the CWS code and require only O(N 2 ) gates.

VI. CONCLUSION
Our protocol for summoning is designed to work for any valid configuration of causal diamonds, where the underlying CSS code depends only on the number of causal diamonds. It is likely that codes can be designed that reduce resource usage by exploiting the structure of causal connections between the causal diamonds, examples being when a single causal curve connects multiple causal diamonds [3] or when the graph representing causal connections is acyclic [4].
While any given configuration of causal diamonds may be realized in man-made quantum networks, a useful avenue of research would be to classify the configurations that can occur naturally in flat or curved spacetimes. Our codes as well as other codes for quantum summoning assume that entangled states may be tranferred without decoherence in spacetime. Quantum summoning in curved spacetime or Rindler coordinates might require the usage of codes that protect against decoherence caused due to gravity or acceleration [30][31][32]. and ∀ u ∈ C 2 , P Z · u = 0. (A5) From T rij ∈ C ⊥ 1 and Eq. (A4), It implies that P X · (e ri + e rj + e ij ) = 0.
Next we prove that Eq. (A5) implies that P Z ∈ C ⊥ 1 . Suppose Then Eq. (A5) implies that for 2 ≤ l ≤Ñ − 1, we have Hence, Thus, (A9) is false and Then Eq. (A5) indicates that for 2 ≤ l ≤Ñ − 1, From Eq. (A12), we know that Thus, which indicates that P Z ∈ C ⊥ 1 . Since P X = 0, we know that P is a Z-type stabilizer in S.
Appendix B: Proof of Lemma 4 Proof. The distance (10) of the stabilizer code in Theorem 1 equals to the minimum weight of the Pauli operators in C(S) \ S [21]. To prove the minimum weight of the Pauli operators in C(S)\S isÑ /2, we first show that there exists a Pauli operator with weightÑ /2 such that P ∈ C(S) \ S. Then we show that no Pauli operator with weight less thanÑ /2 lies in C(S) \ S. From Eq (B1), we know that From Eq. (B2), we find that ∀ l ∈ Ñ , P Z · A l = 1. Hence, ∀ v ∈ C 2 , P Z · v = 0.
From the fact that P X = 0, we know that P (B1) commutes with all the stabilizers in S, i.e., P ∈ C(S). As P Z cannot be represented by an Euclidean cycle, Thus, E / ∈ S, and hence P ∈ C(S) \ S.
For any Pauli operator P with weight less thanÑ /2, there exists an r ∈ Ñ such that ∀k ∈ Ñ \ {r}, P Z · e rk = P X · e rk = 0.
From the discussion in Appendix A, we know that P ∈ C(S) ⇒ P ∈ S.
It implies that P / ∈ C(S) \ S.
Thus, no Pauli operator with weight less thanÑ /2 lies in C(S) \ S.
form a basis of the CSS code in Theorem 1. Hence, the density matrix of the Ñ 2 physical qubits encoding |ψ (47) is To express the reduced density matrix, we give the following notations. The subset of edges connected to r in KÑ is denoted by E r and the complement of E r in E, i.e. the subset of edges not connected to r , is denoted by E c r . In the same way as 2 E K forms a linear space the power set 2 Er forms a linear subspace E r ∼ = ZÑ −1 2 (C4) and the power set 2 E c r forms the orthogonal complement of E r in E , denoted by For a vector v ∈ E , we use v r to denote the projection of v onto E r , and v ⊥ r to denote the projection of v onto E ⊥ r . Now we calculate the reduced density matrix ρ r of thẽ N − 1 qubits q rk ; k ∈ Ñ \ {r} . As where tr E c r denotes the partial trace over the qubits q ij ; i, j ∈ Ñ \ {r} . From the definition of partial trace [33], For each v ∈ E ⊥ r , there is at most one x ∈ C 2 such that Hence, we get x ⊥ r (α |x + β |A r + x ) (α * x| + β * A r + x|) x ⊥ r .
∀x ∈ C 2 , |x r and |1 + x r are the eigenstates of each Hermitian operator in (66) with same eigenvalue, so any linear combination α |x r + β |1 + x r is a common eigenstate of the Hermitian operators (66), with the eigenvalues forming a vector consisting of ±1. For ∀x, z ∈ C 2 and x = z, the two eigenstates α |x r + β |1 + x r (C14) and α |z r + β |1 + z r (C15) have different eigenvalue vectors. This is because if (C14) and (C15) have the same eigenvalues, then either x r = z r or x r = z r +1, both of which contradict condition (C13). Thus, ρ r in Eq. (C12) is an equally weighted mixture of the common eigenstates of the Hermitian operators (66) with different eigenvalue vectors. After the projective measurements on all the Hermitian operators (66), the reduced state is projected onto α |y r + β |1 + y r , where y ∈ C 2 and y r is the projection of y onto E r . The corresponding measurement outcomes are (−1) y (i) r is the i-th component in y r . (C16) is the state after the measurements of the Hermitian operators in (66).