format: text

text:
# Untitled Document

Global phase time and wave function

for the Kantowski–Sachs anisotropic universe

Claudio Simeone111Electronic mail: simeone@tandar.cnea.gov.ar

Departamento de Física, Comisión Nacional de Energía Atómica

Av. del Libertador 8250, 1429 Buenos Aires, Argentina

and

Departamento de Física, Facultad de Ciencias Exactas y Naturales

Universidad de Buenos Aires, Ciudad Universitaria, Pabellón I

1428, Buenos Aires, Argentina.

ABSTRACT

A consistent quantization with a clear notion of time and evolution is given for the anisotropic Kantowski–Sachs cosmological model. It is shown that a suitable coordinate choice allows to obtain a solution of the Wheeler–DeWitt equation in the form of definite energy states, and that the results can be associated to two disjoint equivalent theories, one for each sheet of the constraint surface.

KEY WORDS: Minisuperspace; global phase time; Wheeler–DeWitt equation.

PACS numbers: 04.60.Kz 04.60.Gw 98.80.Hw

1. Introduction

The difficulty in defining a set of observables and a notion of dynamical evolution in a theory where the spacetime metric is itself a dynamical variable, as it is the case of General Relativity, leads to the problem of time in quantum cosmology. The time parameter $`\tau `$ entering the formalism is not a true time, and as a consequence of this, the theory includes a constraint $`0`$ . In the Dirac–Wheeler–DeWitt canonical quantization of minisuperspace models one introduces a wave function $`\mathrm{\Psi }`$ which must fulfill the operator form of the constraint equation, that is,

$$\mathrm{\Psi }=0,$$
(1)
where the momenta are replaced in the usual way by operators in terms of derivatives of the coordinates:

$$p_k=i\frac{}{q^k}.$$

As the Hamiltonian is quadratic in $`p_k`$ a second order differential equation is obtained; this is called the Wheeler–DeWitt equation . It is clear that the solution $`\mathrm{\Psi }`$ does not depend explicitly on the time parameter $`\tau `$, but only on the coordinates $`q^k`$. This is the main problem with the Dirac–Wheeler–DeWitt quantization, because the absence of a clear notion of time makes difficult to have a definition of conserved positive-definite probability, and therefore to guarantee the unitarity of the theory. To build the space of physical states we need to define an inner product which takes into account that there can be a physical time “hidden” among the canonical variables of the system. The physical inner product $`(\mathrm{\Psi }_2|\mathrm{\Psi }_1)`$ must be defined by fixing the time in the integration. If the time can be defined as $`t(q)`$ (intrinsic time) then we can introduce an operator $`\widehat{\mu }_t^{}=\delta (t(q)t^{})`$, which evaluates the product at the fixed time $`t^{}`$. Hence, to obtain a closed theory by this way we need a formally correct definition of time. In fact, if we have been able to isolate the time as a function of the canonical variables, we could work with the new coordinates $`(t,q^\gamma )`$ and the corresponding momenta $`(p_t,p_\gamma )`$ and make the substitution $`p_t=i/t`$, $`p_\gamma =i/q^\gamma `$ to obtain a Wheeler–DeWitt equation whose solution will depend on $`t`$, so that it will have an evolutionary form.

In a previous work we gave a proposal for quantizing the Kantowski–Sachs anisotropic universe with a clear notion of time within the path integral formulation . The procedure was based on a canonical transformation which turned the action of the minisuperspace into that of an ordinary gauge system, which allowed to use canonical gauge conditions to identify a global phase time . A not completely satisfactory point was the form of the resulting propagator: the expression obtained could not be explicitly integrated, so that the interest of the method was almost purely formal. In the present work, instead, we obtain a consistent quantization with a right notion of time and evolution within the canonical formalism; we give an explicit form for the wave function by solving a Wheeler–DeWitt equation in terms of coordinates including a global time and such that the reduced Hamiltonian is time-independent, so that the result can be understood as a set of definite energy states. In the Appendix it is shown that the time here employed in the Wheeler–DeWitt quantization can be obtained with our deparametrization procedure proposed in Ref. 4.

2. The Kantowski–Sachs universe

Possible anisotropic cosmologies are comprised by the Bianchi models and the Kantowski–Sachs model . By introducing the diagonal $`3\times 3`$ matrix $`\beta _{ij}`$, anisotropic spacetime metrics can be put in the form

$$ds^2=N^2d\tau ^2e^{2\mathrm{\Omega }(\tau )}(e^{2\beta (\tau )})_{ij}\sigma ^i\sigma ^j,$$
(2)
with the differential forms $`\sigma ^i`$ fulfilling $`d\sigma ^i=ϵ_{ijk}\sigma ^j\times \sigma ^k`$ . The Kantowski–Sachs model corresponds to the case

$$\beta _{ij}=diag(\beta ,\beta ,2\beta )$$

$$\sigma ^1=d\theta ,\sigma ^2=\mathrm{sin}\theta d\phi ,\sigma ^3=d\psi $$

so that

$$ds^2=N^2d\tau ^2e^{2\mathrm{\Omega }(\tau )}\left(e^{2\beta (\tau )}d\psi ^2+e^{\beta (\tau )}(d\theta ^2+\mathrm{sin}^2\theta d\phi ^2)\right).$$
(3)
Differing from the Bianchi universes, the model is anisotropic even in the case $`\beta _{ij}=0`$. If matter is neglected in the dynamics, the classical behaviour of this universe is analogous to that of the closed Friedmann–Robertson–Walker cosmology in the fact that the volume, defined as

$$𝒱=d^3x\sqrt{(^3g)},$$

grows to a maximun and then returns to zero. This feature is reflected in the form of the scaled Hamiltonian constraint $`H=e^{3\mathrm{\Omega }}`$:

$$H=\pi _\mathrm{\Omega }^2+\pi _\beta ^2e^{4\mathrm{\Omega }+2\beta }0,$$
(4)
which clearly allows for $`\pi _\mathrm{\Omega }=0`$. As a consequence of this, no function of only the coordinate $`\mathrm{\Omega }`$ can be a global phase time for the Kantowski–Sachs universe: the required condition $`[t,H]>0`$  cannot be globally fulfilled by $`t=t(\mathrm{\Omega })`$. In some early works, $`\mathrm{\Omega }`$ was defined as the time coordinate, but this yields a reduced Hamiltonian which is not real for all possible values of $`\beta `$ and $`\pi _\beta `$; hence the corresponding Hamiltonian operator would not be self-adjoint, and the resulting quantum theory would not be unitary.

3. Global time and Wheeler–DeWitt equation

The coordinate $`\beta `$ has a non vanishing Poisson bracket with the constraint (5), then allowing for its use as time variable (this is not true if a matter field is included, as the corresponding additional term $`\pi _\varphi ^2`$ in the constraint makes possible $`\pi _\beta =0`$); but this would lead to a reduced Hamiltonian with a time-dependent potential, making a “one particle” interpretation of the wave function impossible . Then we change to a set of new variables defined as

$`x`$ $``$ $`2\mathrm{\Omega }+\beta `$
$`y`$ $``$ $`\mathrm{\Omega }+2\beta ,`$ (5)
and rescale the Hamiltonian in the following form

$$H\frac{1}{3}H,$$

and thus we obtain the equivalent constraint

$$H=\pi _x^2+\pi _y^2\frac{1}{3}e^{2x}0.$$
(6)
The momentum $`\pi _y`$ does not vanish on the constraint surface; then we have $`[y,H]=2\pi _y0`$ and, up to a sign determined by the sign of $`\pi _y`$, the coordinate $`y`$ is a global phase time:

$$t=ysign(\pi _y).$$
(7)
On the other hand, we have a reduced Hamiltonian on each sheet of the constraint surface: $`h(x,\pi _x)=\pm \sqrt{\pi _x^2+\frac{1}{3}e^{2x}}`$, and the potential does not depend on time.

Now, let us define $`u=\sqrt{\frac{1}{3}}e^x`$. In terms of the coordinates $`u`$ and $`y`$ the Wheeler–DeWitt equation associated to the constraint (6) has the form

$$\left(u^2\frac{d^2}{du^2}+u\frac{d}{du}u^2\frac{d^2}{dy^2}\right)\mathrm{\Psi }(u,y)=0$$
(8)
This equation clearly admits a set of solutions of the form $`\mathrm{\Psi }=A(u)B(y)`$; the solution for $`B(y)`$ is inmediately obtained in the form of exponentials of imaginary argument, while for $`A(u)`$ we have a modified Bessel equation. Returning to the variable $`x`$, the solutions can then be written as

$`\mathrm{\Psi }_\omega (x,y)`$ $`=`$ $`\left[a^+(\omega )e^{i\omega y}+a^{}(\omega )e^{i\omega y}\right]`$ (9)
$`\times \left[b^+(\omega )I_{i\omega }\left(\sqrt{{\displaystyle \frac{1}{3}}}e^x\right)+b^{}(\omega )K_{i\omega }\left(\sqrt{{\displaystyle \frac{1}{3}}}e^x\right)\right],`$
where $`I_{i\omega }`$ and $`K_{i\omega }`$ are modified Bessel functions. The contribution of the functions $`I_{i\omega }\left(\sqrt{\frac{1}{3}}e^x\right)`$ must be discarded, because they diverge in the classicaly forbidden region associated to the exponential potential $`\frac{1}{3}e^{2x}`$. Because the coordinate $`y`$ is a global time, we could separate the functions in (9) as positive and negative-energy solutions, each subset corresponding to one sheet of the constraint surface, that is, to one of both signs of the reduced Hamiltonian. As $`\pi _y=\frac{2}{3}\pi _\beta \frac{1}{3}\pi _\mathrm{\Omega }`$ and on the constraint surface we have $`|\pi _\beta |>|\pi _\mathrm{\Omega }|`$, then $`sign(\pi _y)=sign(\pi _\beta )`$ and each set of solutions corresponds to one of both signs of the original momentum $`\pi _\beta `$. Going back to the original coordinates we can write the wave function(s) as

$`\mathrm{\Psi }_\omega ^+(\mathrm{\Omega },\beta )`$ $`=`$ $`c^+(\omega )e^{i\omega (\mathrm{\Omega }+2\beta )}K_{i\omega }\left(\sqrt{{\displaystyle \frac{1}{3}}}e^{2\mathrm{\Omega }+\beta }\right)`$
$`\mathrm{\Psi }_\omega ^{}(\mathrm{\Omega },\beta )`$ $`=`$ $`c^{}(\omega )e^{i\omega (\mathrm{\Omega }+2\beta )}K_{i\omega }\left(\sqrt{{\displaystyle \frac{1}{3}}}e^{2\mathrm{\Omega }+\beta }\right).`$ (10)
Note, however, that Because $`t=(\mathrm{\Omega }+2\beta )sign(\pi _\beta )`$, we can give a single expression

$$\mathrm{\Psi }_\omega (x=2\mathrm{\Omega }+\beta ,t)=c(\omega )e^{i\omega t}K_{i\omega }\left(\sqrt{\frac{1}{3}}e^x\right)$$
(11)
for both sheets of the constraint surface, reflecting that both disjoint quantum theories are equivalent.

4. Comments

We have given a consistent quantization with a right notion of time for the anisotropic Kantowski–Sachs universe; we have improved previous analysis , by giving and explicit form of the wave function, which results of a Wheeler–DeWitt equation with a coordinate as a global time. This allows for a right definition of the space of physical states; if the solutions are given in terms of the time $`t`$, the Klein–Gordon inner product defined as

$$(\mathrm{\Psi }_1|\mathrm{\Psi }_2)=\frac{i}{2}_{t=const}𝑑x\left[\mathrm{\Psi }_1^{}\frac{\mathrm{\Psi }_2}{t}\mathrm{\Psi }_2\frac{\mathrm{\Psi }_1^{}}{t}\right],$$

is conserved and positive-definite. A point to be signaled is that we can also define the inner product in the space of physical states as a Schrödinger inner product,

$$(\mathrm{\Psi }_1|\mathrm{\Psi }_2)=\mathrm{\Psi }_1|\widehat{\mu }|\mathrm{\Psi }_2$$

with $`\widehat{\mu }=\delta (yy^{})`$, because the Hamiltonian $`H`$ admits a factorization in the form of a product of two constraints linear in $`\pi _y=\pm \pi _t`$, each one leading to a Schrödinger equation . This is possible because in terms of the new coordinates $`(x,y)`$ the potential does not depend on time, and therefore $`\pi _t`$ conmutes with the reduced Hamiltonian $`h`$. Recall that such a factorization is not possible if we work with the original coordinates $`\mathrm{\Omega },\beta `$; in this case $`t=\pm \beta `$, and $`\pi _t`$ does not conmute with the (time-dependent) reduced Hamiltonian $`h=\pm \sqrt{\pi _\mathrm{\Omega }^2+e^{4\mathrm{\Omega }+2\beta }}`$.

It should be noted that we have started from a scaled constraint $`H=e^{3\mathrm{\Omega }}`$, which at the classical level is equivalent to $``$, but which does not necessarily lead to the same quantum description. However, it can be shown that an operator ordering exists such that both constraints $`H`$ and $``$ are equivalent at the quantum level. Let us consider a generic constraint

$$e^{bq_1}\left(p_1^2+p_2^2+\zeta e^{aq_1+cq_2}\right)0,$$

which contains an ambiguity associated to the fact that the most general form of the first term should be written

$$e^{Aq_1}p_1e^{(bAC)q_1}p_1e^{Cq_1}$$

(so that $`A`$ and $`C`$ parametrize all possible operator orderings). It is simple to verify that the constraint with the most general ordering differs from that with the trivial ordering in two terms, one linear and one quadratic in $`\mathrm{}`$, and that these terms vanish with the choice $`C=bA=0`$. Therefore, the Wheeler–DeWitt equation resulting from the scaled constraint $`H`$ is right in the sense that it corresponds to a possible ordering of the original constraint $``$.

A final remark should be that the obtention of two disjoint theories corresponding to both sheets of the constraint surface is possible because the model under consideration admits an intrinsic time: the time is given by the coordinate conjugated to the non vanishing momentum whose sign identifies each sheet. In the case of a model such that all the momenta could vanish, the procedure could still be carried out if a canonical transformation leading to a non vanishing potential can be performed .

Acknowledgement

I wish to thank G. Giribet and F. D. Mazzitelli for very helpful comments.

Appendix

In Ref. 4 we proposed a deparametrization procedure based in a canonical transformation turning the minisuperspace into an ordinary gauge system, so that a $`\tau `$-dependent canonical gauge condition could be used to define a global phase time . The generating function of the transformation must be a solution of the Hamilton–Jacobi equation

$$H(q^k,\frac{W}{q^k})=E$$

which results of matching the $`E`$ to one of the new momenta, for example $`\overline{P}_0`$. Therefore the Poisson bracket of the new coordinate $`\overline{Q}^0`$ with the constraint $`H`$ is equal to unity, and $`\overline{Q}^0`$ can be used to fix the gauge. In Ref. 4 we started from a different expression for the constraint, and the resulting (intrinsic) time had the form of an exponencial of $`\mathrm{\Omega }`$ and $`\beta `$.

It is simple to verify that this method can reproduce the definition of time given here. If we start from the constraint (6) we obtain the Hamilton–Jacobi equation

$$\left(\frac{W}{x}\right)^2+\left(\frac{W}{y}\right)^2\frac{1}{3}e^{2x}=E.$$

Introducing the integration constants $`\overline{P}_0=E`$ and $`a`$ such that $`a^2+E=\pi _y^2`$ we obtain the solution

$$W=ysign(\pi _y)\sqrt{a^2+\overline{P}_0}+sign(\pi _x)𝑑x\sqrt{a^2\frac{1}{3}e^{2x}}$$

so that

$$\overline{Q}^0=\frac{W}{\overline{P}_0}=\frac{ysign(\pi _y)}{2\sqrt{a^2+\overline{P}_0}}.$$

Then we can fix the gauge by means of the canonical condition $`\chi 2\overline{Q}^0\sqrt{a^2+\overline{P}_0}T(\tau )=0`$ with $`T`$ a monotonous function of $`\tau `$, which yields $`t=ysign(\pi _y)`$. We could also define a time including the momenta (extrinsic time) by fixing $`\chi 2\overline{Q}^0T(\tau )=0`$, which gives $`t=y/\pi _y`$.

References

1. Barvinsky A. O., Phys. Rep. 230, 237 (1993).

2. Ferraro R., Grav. Cosm. 5, 195 (1999).

3. Halliwell J. J., in Introductory Lectures on Quantum Cosmology, Proceedings of the Jerusalem Winter School on Quantum Cosmology and Baby Universes, edited by T. Piran, World Scientific, Singapore (1990).

4. Simeone C., Gen. Rel. Grav. 32, 1835 (2000).

5. De Cicco H. and Simeone C., Gen. Rel. Grav. 31, 1225 (1999).

6. Simeone C., J. Math. Phys. 40, 4527 (1999).

7. Ryan M. P. and Shepley L. C., Homogeneous Relativistic Cosmologies, Princeton Series in Physics, Princeton University Press, New Jersey (1975).

8. Kantowski R. and Sachs R. K., J. Math. Phys. 7, 443 (1966).

9. Higuchi A. and Wald R. M., Phys. Rev. D51, 544 (1995)

10. Schutz B. F., Geometrical Methods of Mathematical Physics, Cambridge University Press, Cambridge (1980).

11. Hájícek P., Phys. Rev. D34, 1040 (1986).

12. Kuchař K. V., in Quantum Gravity 2: A Second Oxford Symposyum, edited by C. J. Isham, R. Penrose and D. W. Sciama, Clarendon Press (1981).

13. Cavaglià M., De Alfaro V. and Filippov A. T., Int. J. Mod. Phys. A10, 611 (1995).

14. Catren G. and Ferraro R., Phys. Rev. D63, 023502 (2001).

15. G. Giribet and C. Simeone, Int. J. Mod. Phys. A17, 2885 (2002)).


text:
# Perfectly Secure Message Transmission RevisitedAn extended abstract of this paper has appeared in [3]

## 1 Introduction

If there is a private and authenticated channel between two parties, then secure communication between them is guaranteed. However, in most cases, many parties are only indirectly connected, as elements of an incomplete network of private and authenticated channels. In other words they need to use intermediate or internal nodes. Achieving participants cooperation in the presence of faults is a major problem in distributed networks. Original work on secure distributed computation assumed a complete graph for secure and reliable communication. Dolev, Dwork, Waarts, and Yung  were able to reduce the size of the network graph by providing protocols that achieve private and reliable communication without the need for the parties to start with secret keys. The interplay of network connectivity and secure communication has been studied extensively (see, e.g., ). For example, Dolev  and Dolev et al.  showed that, in the case of $`k`$ Byzantine faults, reliable communication is achievable only if the system’s network is $`2k+1`$ connected. They also showed that if all the paths are one way, then $`3k+1`$ connectivity is necessary and sufficient for reliable and private communications. However they did not prove any results for the general case when there are certain number of directed paths in one direction and another number of directed paths in the other direction. While undirected graphs correspond naturally to the case of pairwise two-way channels, directed graphs do not correspond to the case of all-one-way or all-two-way channels considered in , but to the mixed case where there are some paths in one direction and some paths in the other direction. In this paper, we will initiate the study in this direction by showing what can be done with a general directed graph. Note that this scenario is important in practice, in particular, when the network is not symmetric. For example, a channel from $`A`$ to $`B`$ is cheap and a channel from $`B`$ to $`A`$ is expensive but not impossible. Another example is that $`A`$ has access to more resources than $`B`$ does.

Goldreich, Goldwasser, and Linial , Franklin and Yung , Franklin and Wright , and Wang and Desmedt  have studied secure communication and secure computation in multi-recipient (multicast) models. In a “multicast channel” (such as Ethernet), one participant can send the same message—simultaneously and privately—to a fixed subset of participants. Franklin and Yung  have given a necessary and sufficient condition for individuals to exchange private messages in multicast models in the presence of passive adversaries (passive gossipers). For the case of active Byzantine adversaries, many results have been presented by Franklin and Wright , and, Wang and Desmedt . Note that Goldreich, Goldwasser, and Linial  have also studied fault-tolerant computation in the public multicast model (which can be thought of as the largest possible multirecipient channels) in the presence of active Byzantine adversaries. Specifically, Goldreich, et al.  have made an investigation of general fault-tolerant distributed computation in the full-information model. In the full information model no restrictions are made on the computational power of the faulty parties or the information available to them. (Namely, the faulty players may be infinitely powerful and there are no private channels connecting pairs of honest players). In particular, they present efficient two-party protocols for fault-tolerant computation of any bivariate function.

There are many examples of multicast channels (see, e.g. ), such as an Ethernet bus or a token ring. Another example is a shared cryptographic key. By publishing an encrypted message, a participant initiates a multicast to the subset of participants that is able to decrypt it.

We present our model in Section 2. In Sections 3 and 4, we study secure message transmission over directed graphs. Section 6 is devoted to reliable message transmission over hypergraphs, and Section 7 is devoted to secure message transmission over neighbor networks.

## 2 Model

We will abstract away the concrete network structures and consider directed graphs. A directed graph is a graph $`G(V,E)`$ where all edges have directions. For a directed graph $`G(V,E)`$ and two nodes $`A,BV`$, throughout this paper, $`n`$ denotes the number of vertex disjoint paths between the two nodes and $`k`$ denotes the number of faults under the control of the adversary. We write $`|S|`$ to denote the number of elements in the set $`S`$. We write $`x_RS`$ to indicate that $`x`$ is chosen with respect to the uniform distribution on $`S`$. Let F be a finite field, and let $`a,b,c,M𝐅`$. We define $`\text{auth}(M;a,b):=aM+b`$ (following ) and $`\text{auth}(M;a,b,c):=aM^2+bM+c`$ (following ). Note that each authentication key $`key=(a,b)`$ can be used to authenticate one message $`M`$ without revealing any information about any component of the authentication key and that each authentication key $`key=(a,b,c)`$ can be used to authenticate two messages $`M_1`$ and $`M_2`$ without revealing any information about any component of the authentication key. We will also use a function $`\mathrm{}`$ which maps a variable size (we assume that this variable size is bounded by a pre-given bound) ordered subset of F to an image element in a field extension $`𝐅^{}`$ of F, and from any image element we can uniquely and efficiently recover the ordered subset. Let $`k`$ and $`n`$ be two integers such that $`0k<n3k+1`$. A $`(k+1)`$-out-of-$`n`$ secret sharing scheme is a probabilistic function S: $`𝐅𝐅^n`$ with the property that for any $`M𝐅`$ and $`\text{S}(M)=(v_1,\mathrm{},v_n)`$, no information of $`M`$ can be inferred from any $`k`$ entries of $`(v_1,\mathrm{},v_n)`$, and $`M`$ can be recovered from any $`k+1`$ entries of $`(v_1,\mathrm{},v_n)`$. The set of all possible $`(v_1,\mathrm{},v_n)`$ is called a code and its elements codewords. We say that a $`(k+1)`$-out-of-$`n`$ secret sharing scheme can detect $`k^{}`$ errors if given any codeword $`(v_1,\mathrm{},v_n)`$ and any tuple $`(u_1,\mathrm{},u_n)`$ over F such that $`0<|\{i:u_iv_i,1in\}|k^{}`$ one can detect that $`(u_1,\mathrm{},u_n)`$ is not a codeword. If the code is Maximal Distance Separable, then the maximum value of errors that can be detected is $`nk1`$ . We say that the $`(k+1)`$-out-of-$`n`$ secret sharing scheme can correct $`k^{}`$ errors if from any $`\text{S}(M)=(v_1,\mathrm{},v_n)`$ and any tuple $`(u_1,\mathrm{},u_n)`$ over F with $`|\{i:u_iv_i,1in\}|k^{}`$ one can recover the secret $`m`$. If the code is Maximal Distance Separable, then the maximum value of errors that allows the recovery of the vector $`(v_1,\mathrm{},v_n)`$ is $`(nk1)/2`$ . A $`(k+1)`$-out-of-$`n`$ Maximal Distance Separable (MDS) secret sharing scheme is a $`(k+1)`$-out-of-$`n`$ secret sharing scheme with the property that for any $`k^{}(nk1)/2`$, one can correct $`k^{}`$ errors and simultaneously detect $`nkk^{}1`$ errors (as follows easily by generalizing \[12, p. 10\]). Maximal Distance Separable (MDS) secret sharing schemes can be constructed from any MDS codes, for example, from Reed-Solomon code .

In a message transmission protocol, the sender $`A`$ starts with a message $`M^A`$ drawn from a message space $``$ with respect to a certain probability distribution. At the end of the protocol, the receiver $`B`$ outputs a message $`M^B`$. We consider a synchronous system in which messages are sent via multicast in rounds. During each round of the protocol, each node receives any messages that were multicast for it at the end of the previous round, flips coins and perform local computations, and then possibly multicasts a message. We will also assume that the message space $``$ is a subset of a finite field F.

We consider two kinds of adversaries. A passive adversary (or gossiper adversary) is an adversary who can only observe the traffic through $`k`$ internal nodes. An active adversary (or Byzantine adversary) is an adversary with unlimited computational power who can control $`k`$ internal nodes. That is, an active adversary will not only listen to the traffics through the controlled nodes, but also control the message sent by those controlled nodes. Both kinds of adversaries are assumed to know the complete protocol specification, message space, and the complete structure of the graph. In this paper, we will not consider a dynamic adversary who could change the nodes it controls from round to round, instead we will only consider static adversaries. That is, at the start of the protocol, the adversary chooses the $`k`$ faulty nodes. An alternative interpretation is that $`k`$ nodes are static collaborating adversaries.

For any execution of the protocol, let $`adv`$ be the adversary’s view of the entire protocol. We write $`adv(M,r)`$ to denote the adversary’s view when $`M^A=M`$ and when the sequence of coin flips used by the adversary is $`r`$.

###### Definition 2.1

(see Franklin and Wright )

1. Let $`\delta <\frac{1}{2}`$. A message transmission protocol is $`\delta `$-reliable if, with probability at least $`1\delta `$, $`B`$ terminates with $`M^B=M^A`$. The probability is over the choices of $`M^A`$ and the coin flips of all nodes.
2. A message transmission protocol is reliable if it is $`0`$-reliable.
3. A message transmission protocol is $`\epsilon `$-private if, for every two messages $`M_0,M_1`$ and every $`r`$, $`_c|\mathrm{Pr}[adv(M_0,r)=c]\mathrm{Pr}[adv(M_1,r)=c]|2\epsilon .`$ The probabilities are taken over the coin flips of the honest parties, and the sum is over all possible values of the adversary’s view.
4. A message transmission protocol is perfectly private if it is $`0`$-private.
5. A message transmission protocol is $`(\epsilon ,\delta )`$-secure if it is $`\epsilon `$-private and $`\delta `$-reliable.
6. An $`(\epsilon ,\delta )`$-secure message transmission protocol is efficient if its round complexity and bit complexity are polynomial in the size of the network, $`\mathrm{log}\frac{1}{\epsilon }`$ (if $`\epsilon >0`$) and $`\mathrm{log}\frac{1}{\delta }`$ (if $`\delta >0`$).

For two nodes $`A`$ and $`B`$ in a directed graph such that there are $`2k+1`$ node disjoint paths from $`A`$ to $`B`$, there is a straightforward reliable message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary: $`A`$ sends the message $`m`$ to $`B`$ via all the $`2k+1`$ paths, and $`B`$ recovers the message $`m`$ by a majority vote.

## 3 $`(0,\delta )`$-Secure message transmission in directed graphs

Our discussion in this section will be concentrated on directed graphs. Dolev, Dwork, Waarts, and Yung  addressed the problem of secure message transmissions in a point-to-point network. In particular, they showed that if all channels from $`A`$ to $`B`$ are one-way, then $`(3k+1)`$-connectivity is necessary and sufficient for (0,0)-secure message transmissions from $`A`$ to $`B`$ against a $`k`$-active adversary. They also showed that if all channels between $`A`$ and $`B`$ are two-way, then $`(2k+1)`$-connectivity is necessary and sufficient for (0,0)-secure message transmissions between $`A`$ and $`B`$ against a $`k`$-active adversary. In this section we assume that there are only $`2k+1u`$ directed node disjoint paths from $`A`$ to $`B`$, where $`1uk`$. We show that $`u`$ directed node disjoint paths from $`B`$ to $`A`$ are necessary and sufficient to achieve $`(0,\delta )`$-secure message transmissions from $`A`$ to $`B`$ against a $`k`$-active adversary.

Franklin and Wright  showed that even if all channels between $`A`$ and $`B`$ are two way, $`2k+1`$ channels between $`A`$ and $`B`$ are still necessary for $`(1\delta )`$-reliable (assuming that $`\delta <\frac{1}{2}\left(1\frac{1}{|𝐅|}\right)`$) message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary.

###### Theorem 3.1

(Frandlin and Wright ) Let $`G(V,E)`$ be a directed graph, $`A,BV`$, and there are only $`2k`$ two-way node disjoint paths between $`A`$ and $`B`$ in $`G`$. Then $`\delta `$-reliable message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary is impossible for $`\delta <\frac{1}{2}\left(1\frac{1}{|𝐅|}\right)`$.

In the following, we first show that if there is no directed path from $`B`$ to $`A`$, then $`2k+1`$ directed paths from $`A`$ to $`B`$ is necessary and sufficient for $`(0,\delta )`$-secure message transmission from $`A`$ to $`B`$.

###### Theorem 3.2

Let $`G(V,E)`$ be a directed graph, $`A,BV`$, and $`0<\delta <\frac{1}{2}`$. If there is no directed paths from $`B`$ to $`A`$, then the necessary and sufficient condition for $`(0,\delta )`$-secure message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary is that there are $`2k+1`$ directed node disjoint paths from $`A`$ to $`B`$.

Proof. The necessity is proved in Theorem 3.1. Let $`p_1,\mathrm{},p_{2k+1}`$ be the $`2k+1`$ directed node disjoint paths from $`A`$ to $`B`$. Let $`M^A𝐅`$ be the secret that $`A`$ wants to send to $`B`$. $`A`$ constructs $`(k+1)`$-out-of-$`(2k+1)`$ secret shares $`(s_1^A,\mathrm{},s_{2k+1}^A)`$ of $`M^A`$. The protocol proceeds from round $`1`$ through round $`2k+1`$. In each round $`1i2k+1`$, we have the following steps:

* $`A`$ chooses $`\{(a_{i,j}^A,b_{i,j}^A)_R𝐅^2:1j2k+1\}`$.
* $`A`$ sends $`(s_i^A,\text{auth}(s_i^A;a_{i,1}^A,b_{i,1}^A),\mathrm{},\text{auth}(s_i^A;a_{i,2k+1}^A,b_{i,2k+1}^A))`$ to $`B`$ via path $`p_i`$, and sends $`(a_{i,j}^A,b_{i,j}^A)`$ to $`B`$ via path $`p_j`$ for each $`1j2k+1`$.
* $`B`$ receives $`(s_i^B,c_{i,1}^B,\mathrm{},c_{i,2k+1}^B)`$ via path $`p_i`$, and receives $`(a_{i,j}^B,b_{i,j}^B)`$ via path $`p_j`$ for each $`1j2k+1`$.
* $`B`$ computes $`t=|\{j:c_{i,j}^B=\text{auth}(s_i^B;a_{i,j}^B,b_{i,j}^B)\}|`$. If $`tk+1`$, then $`B`$ decides that $`s_i^B`$ is a valid share. Otherwise $`B`$ discards $`s_i^B`$.

It is easy to check that after the round $`2k+1`$, with high probability, $`B`$ will get at least $`k+1`$ valid shares of $`s^A`$. Thus, with high probability, $`B`$ will recover the secret $`M^B=M^A`$. It is straightforward that the protocol achieves perfect privacy. Thus the above protocol is a $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary. Q.E.D. $`\mathrm{}`$

By Theorem 3.1, the necessary condition for $`(0,\delta )`$-secure message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary is that there are at least $`k+1`$ node disjoint paths from $`A`$ to $`B`$ and there are at least $`2k+1`$ node disjoint paths in total from $`A`$ to $`B`$ and from $`B`$ to $`A`$. In the following, we show that this condition is also sufficient. We first show that the condition is sufficient for $`k=1`$.

###### Theorem 3.3

Let $`G(V,E)`$ be a directed graph, $`A,BV`$. If there are two directed node disjoint paths $`p_0`$ and $`p_1`$ from $`A`$ to $`B`$, and one directed path $`q`$ (which is node disjoint from $`p_0`$ and $`p_1`$) from $`B`$ to $`A`$, then for any $`0<\delta <\frac{1}{2}`$, there is a $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$ against a 1-active adversary.

Proof. In the following protocol, $`A`$ $`(0,\delta )`$-securely transmits a message $`M^A𝐅`$ to $`B`$.

* $`A`$ chooses $`s_0^A_R𝐅`$, $`(a_0^A,b_0^A),(a_1^A,b_1^A)_R𝐅^2`$, and let $`s_1^A=M^As_0^A`$. For each $`i\{0,1\}`$, $`A`$ sends $`(s_i^A,(a_i^A,b_i^A),\text{auth}(s_i^A;a_{1i}^A,b_{1i}^A))`$ to $`B`$ via path $`p_i`$.
* Assumes that $`B`$ receives $`(s_i^B,(a_i^B,b_i^B),c_i^B)`$ via path $`p_i`$. $`B`$ checks whether $`c_i^B=\text{auth}(s_i^B;a_{1i}^B,b_{1i}^B)`$ for $`i=0,1`$. If both equations hold, then $`B`$ knows that with high probability the adversary was either passive or not on the paths from $`A`$ to $`B`$. $`B`$ can recover the secret message, sends “OK” to $`A`$ via the path $`q`$, and terminates the protocol. Otherwise, one of equations does not hold and $`B`$ knows that the adversary was on one of the paths from $`A`$ to $`B`$. In this case, $`B`$ chooses $`(a^B,b^B)_R𝐅^2`$, and sends $`((a^B,b^B),(s_0^B,(a_0^B,b_0^B),c_0^B),(s_1^B,(a_1^B,b_1^B),c_1^B))`$ to $`A`$ via the path $`q`$.
* If $`A`$ receives “OK”, then $`A`$ terminates the protocol. Otherwise, from the information $`A`$ received via path $`q`$, $`A`$ decides which path from $`A`$ to $`B`$ is corrupted and recovers $`B`$’s authentication key $`(a^A,b^A)`$. $`A`$ sends $`(M^A,\text{auth}(M^A;a^A,b^A))`$ to $`B`$ via the uncorrupted path from $`A`$ to $`B`$.
* $`B`$ recovers the message and checks that the authenticator is correct.

Similarly as in the proof of Theorem 3.2, it can be shown that the above protocol is $`(0,\delta )`$-secure against a $`1`$-active adversary. Q.E.D. $`\mathrm{}`$

###### Theorem 3.4

Let $`G(V,E)`$ be a directed graph, $`A,BV`$, and $`ku1`$. If there are $`2k+1u`$ directed node disjoint paths $`p_1`$, $`\mathrm{}`$, $`p_{2k+1u}`$ from $`A`$ to $`B`$, and $`u`$ directed node disjoint paths $`q_1`$, $`\mathrm{}`$, $`q_u`$ ($`q_1`$, $`\mathrm{}`$, $`q_u`$ are node disjoint from $`p_1`$, $`\mathrm{}`$, $`p_{2k+1u}`$) from $`B`$ to $`A`$, then for any $`0<\delta <\frac{1}{2}`$, there is an efficient $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Before we give an efficient $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$. We first demonstrate the underlying idea by giving a non-efficient (exponential in $`k`$) $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary. Let $`M^A𝐅`$ be the secret that $`A`$ wants to send to $`B`$, and $`𝒫_1,\mathrm{},𝒫_t`$ be an enumeration of size $`k+1`$ subsets of $`\{p_1,\mathrm{},p_{2k+1u},q_1,\mathrm{},q_u\}`$. The protocol proceeds from round $`1`$ through $`t`$. In each round $`1mt`$, we have the following steps:

* For each $`p_i𝒫_m`$, $`A`$ chooses $`(a_{i,m}^A,b_{i,m}^A)_R𝐅^2`$ and sends $`(a_{i,m}^A,b_{i,m}^A)`$ to $`B`$ via $`p_i`$.
* For each $`p_i𝒫_m`$, $`B`$ receives $`(a_{i,m}^B,b_{i,m}^B)`$ from $`A`$ via $`p_i`$.
* For each $`q_i𝒫_m`$, $`B`$ chooses $`(c_{i,m}^B,d_{i,m}^B)_R𝐅^2`$ and sends $`(c_{i,m}^B,d_{i,m}^B)`$ to $`A`$ via $`q_i`$.
* For each $`q_i𝒫_m`$, $`A`$ receives $`(c_{i,m}^A,d_{i,m}^A)`$ from $`B`$ via $`q_i`$.
* $`A`$ computes $`C^A=_{p_i𝒫_m}a_{i,m}^A+_{q_i𝒫_m}c_{i,m}^A`$, $`D^A=_{p_i𝒫_m}b_{i,m}^A+_{q_i𝒫_m}d_{i,m}^A`$, and sends $`(M^A+C^A,\text{auth}(M^A+C^A;C^A,D^A))`$ to $`B`$ via all paths in $`p_i`$ in $`𝒫_m`$.
* For each $`p_i𝒫_m`$, $`B`$ receives $`(e_{i,m}^B,f_{i,m}^B)`$ from $`A`$ via $`p_i`$.
* If $`(e_{i,m}^B,f_{i,m}^B)=(e_{j,m}^B,f_{j,m}^B)`$ for all $`p_i,p_j𝒫_m`$, then $`B`$ goes to Step 8. Otherwise, $`B`$ goes to round $`m+1`$.
* $`B`$ computes $`C^B=_{p_i𝒫_m}a_{i,m}^B+_{q_i𝒫_m}c_{i,m}^B`$, $`D^B=_{p_i𝒫_m}b_{i,m}^B+_{q_i𝒫_m}d_{i,m}^B`$.
* If $`f_{i,m}^B=\text{auth}(f_{i,m}^B;C^B,D^B)`$, then $`B`$ computes the secret $`M^B=f_{i,m}^BC^B`$ and terminates the protocol. Otherwise, $`B`$ goes to round $`m+1`$.

Since there is at least one $`𝒫_m`$ such that all paths in $`𝒫_m`$ are not corrupted, $`B`$ receives the correct secret by the end of the protocol with high probability. It is also straightforward to check that the above protocol has perfect secrecy.

Proof. (Proof of Theorem 3.4) Let $`M^A𝐅`$ be the secret that $`A`$ wants to send to $`B`$. $`A`$ constructs $`(k+1)`$-out-of-$`(2k+1u)`$ secret shares $`(s_1^A,\mathrm{},s_{2k+1u}^A)`$ of $`M^A`$. The protocol proceeds from round $`1`$ through $`2k+2+u`$. For each round $`1i2k+1u`$, we have the following steps:

* $`A`$ chooses $`\{(a_{i,j}^A,b_{i,j}^A)_R𝐅^2`$, $`:1j2k+1u\}`$.
* $`A`$ sends $`\{s_i^A,\text{auth}(s_i^A;a_{i,1}^A,b_{i,1}^A)`$, $`\mathrm{}`$, $`\text{auth}(s_i^A;a_{i,2k+1u}^A,b_{i,2k+1u}^A)\}`$ to $`B`$ via path $`p_i`$, and sends $`(a_{i,j}^A,b_{i,j}^A)`$ to $`B`$ via path $`p_j`$ for each $`1j2k+1u`$.
* $`B`$ receives $`\{s_i^B,d_{i,1}^B,\mathrm{},d_{i,2k+1u}^B\}`$ via path $`p_i`$, and $`(a_{i,j}^B,b_{i,j}^B)`$ via path $`p_j`$ for each $`1j2k+1u`$.
* $`B`$ computes $`t=|\{j:d_{i,j}^B=\text{auth}(s_i^B;a_{i,j}^B,b_{i,j}^B)\}|`$. If $`tk+1`$, then $`B`$ decides that $`s_i^B`$ is a valid share. Otherwise $`B`$ decides that $`s_i^B`$ is an invalid share.

At the end of round $`2k+1u`$, if $`B`$ has received $`k+1`$ valid shares, then $`B`$ recovers the secret $`M^B`$ from these valid shares and terminates the protocol. Otherwise, $`B`$ proceeds to round $`2k+2u`$. In round $`2k+2u`$, we have the following steps:

* $`A`$ chooses $`\{(a_i^A,b_i^A,c_i^A)_R𝐅^3`$ $`:1i2k+1u\}`$, and sends $`(a_i^A,b_i^A,c_i^A)`$ to $`B`$ via path $`p_i`$ for each $`i2k+1u`$.
* For each $`1i2k+1u`$, $`B`$ receives $`(a_i^B,b_i^B,c_i^B)`$ on path $`p_i`$ from $`A`$ (if no value is received on path $`p_i`$, $`B`$ sets it to a default value).
* For each $`1i2k+1u`$, $`B`$ chooses $`r_i^B_R𝐅`$ and computes $`\beta ^B=\{(r_i^B,\text{auth}(r_i^B;a_i^B,b_i^B,c_i^B)):1i2k+1u\}`$.

In each round $`2k+3ui2k+2`$, we have the following steps:

* $`B`$ chooses $`(d_i^B,e_i^B)_R𝐅^2`$ and $`\{(v_{i,j}^B,w_{i,j}^B)_R𝐅^2:1ju\}`$.
* $`B`$ sends $`(d_i^B,e_i^B)`$, $`\beta ^B`$, and $`\{\text{auth}(d_i^B,e_i^B;v_{i,j}^B,w_{i,j}^B)`$ $`:1ju\}`$ to $`A`$ via path $`q_i`$, and $`(v_{i,j}^B,w_{i,j}^B)`$ to $`A`$ via path $`q_j`$ for each $`1ju`$.
* $`A`$ receives (or substitutes default values) $`(d_i^A,e_i^A)`$, $`\beta _i^A`$, and $`\{\alpha _{i,j}^A:1ju\}`$ from $`B`$ via path $`q_i`$, and $`(v_{i,j}^A,w_{i,j}^A)`$ from $`B`$ via path $`q_j`$ for each $`1ju`$.

According to the values that $`A`$ has received, $`A`$ divides the paths set $`\{q_1,\mathrm{},q_u\}`$ into subsets $`𝒬_1,\mathrm{},𝒬_t`$ such that for any $`l,m,n`$ with $`1lt`$, $`1m,nu`$, and $`q_m,q_n𝒬_l`$, we have

1. $`\beta _m^A=\beta _n^A`$;
2. $`\alpha _{m,n}^A=\text{auth}(d_m^B,e_m^B;v_{m,n}^B,w_{m,n}^B)`$;
3. $`\alpha _{n,m}^A=\text{auth}(d_n^B,e_n^B;v_{n,m}^B,w_{n,m}^B)`$.

For each $`𝒬_l`$, let $`q_m𝒬_l`$ and $`\beta _m^A=\{(r_{i,l}^A,\gamma _{i,l}^A):1i2k+1u\}`$. $`A`$ computes the number

$$t_l=|\{i:\gamma _{i,l}^A=\text{auth}(r_{i,l}^A;a_i^A,b_i^A,c_i^A),1i2k+1u\}|+|𝒬_l|$$

If $`t_lk`$, then $`A`$ decides that $`𝒬_l`$ is an unacceptable set, otherwise, $`A`$ decides that $`𝒬_l`$ is an acceptable set. Let $`𝒬_l=\mathrm{}`$ for $`t<lu`$.

For each round $`2k+3l2k+2+u`$, we have the following steps:

* If $`𝒬_l=\mathrm{}`$ or $`𝒬_l`$ is an unacceptable set, then go to round $`l+1`$.
* $`A`$ computes $`𝒫_l=\{p_i:\gamma _{i,l}^A=\text{auth}(r_{i,l}^A;a_i^A,b_i^A,c_i^A),1i2k+1u\}`$, $`C_l^A=_{p_i𝒫_l}a_i^A+_{q_i𝒬_l}d_i^A`$, and $`D_l^A=_{p_i𝒫_l}b_i^A+_{q_i𝒬_l}e_i^A`$.
* $`A`$ sends $`(𝒬_l,𝒫_l,M^A+C_l^A,\text{auth}(𝒬_l,𝒫_l,M^A+C_l^A;C_l^A,D_l^A))`$ to $`B`$ via all paths $`p_i𝒫_l`$.
* $`B`$ receives $`(\alpha _{i,l}^B,\beta _{i,l}^B)`$ from path $`p_i`$ for $`1i2k+1u`$.
* For each $`1i2k+1u`$, $`B`$ computes $`\alpha _{i,l}^B=𝒬_{i,l}^B,𝒫_{i,l}^B,\beta _{i,l}^B`$, $`C_{i,l}^B=_{p_j𝒫_{i,l}}a_j^B+_{q_j𝒬_{i,l}}d_j^B`$, and $`D_{i,l}^B=_{p_j𝒫_{i,l}}b_j^B+_{q_j𝒬_{i,l}}e_j^B`$.
* For each $`1i2k+1u`$, $`B`$ checks whether $`\beta _{i,l}^B=\text{auth}(\alpha _{i,l}^B;C_{i,l}^B,D_{i,l}^B)`$. If the equation holds, then $`B`$ computes the secret $`M^B=\beta _{i,l}^BC_{i,l}^B`$.

If $`B`$ has not got the secret at the end of round $`2k+1u`$, then there exists an uncorrupted path $`q_j`$ from $`B`$ to $`A`$ and a paths set $`𝒬_l`$ such that $`q_j𝒬_l`$ and the information that $`A`$ receives from paths in $`𝒬_l`$ are reliable. Thus, at the end of round $`2k+2+u`$, $`B`$ will output a secret $`M^B`$. It is easy to check that, with high probability, this secret is the same as $`M^A`$.

It is straightforward to show that the protocol achieves perfect privacy. Thus it is a $`(0,\delta )`$-secure message transmission transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary. Q.E.D. $`\mathrm{}`$

## 4 $`(0,0)`$-Secure message transmission in directed graphs

In the previous section, we addressed probabilistic reliable message transmission in directed graphs. In this section, we consider perfectly reliable message transmission in directed graphs. We will show that if there are $`u`$ directed node disjoint paths from $`B`$ to $`A`$, then a necessary and sufficient condition for $`(0,0)`$-secure message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary is that there are $`\mathrm{max}\{3k+12u,2k+1\}`$ directed node disjoint paths from $`A`$ to $`B`$.

###### Theorem 4.1

Let $`G(V,E)`$ be a directed graph, $`A,BV`$. Assume that there are $`u`$ directed node disjoint paths from $`B`$ to $`A`$. Then a necessary condition for $`(0,0)`$-secure message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary is that there are $`\mathrm{max}\{3k+12u,2k+1\}`$ directed node disjoint paths from $`A`$ to $`B`$.

Proof. If $`u=0`$, then by the results in , we need $`3k+1`$ directed node disjoint paths from $`A`$ to $`B`$ for $`(0,0)`$-secure message transmission against a $`k`$-active adversary. If $`u\frac{k}{2}`$, then again by the results in , we need $`2k+1`$ directed node disjoint paths from $`A`$ to $`B`$ for $`0`$-reliable (that is, perfectly reliable) message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary. From now on, we assume that $`0<u<\frac{k}{2}`$.

For a contradiction, we assume that there are only $`3k2u`$ directed node disjoint paths from $`A`$ to $`B`$, denoted as $`p_1,\mathrm{},p_{3k2u}`$. Let $`q_1,\mathrm{},q_u`$ be the directed node disjoint paths from $`B`$ to $`A`$.

Let $`\mathrm{\Pi }`$ be a $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$. In the following, we will construct a $`k`$-active adversary to defeat this protocol. The transcripts distribution $`view_\mathrm{\Pi }^A`$ of $`A`$ is drawn from a probability distribution that depends on the message $`M^A`$ to be transmitted by $`A`$, the coin flips $`R^A`$ of $`A`$, the coin flips $`R^B`$ of $`B`$, the coin flips $`R^𝒜`$ of the adversary (without loss of generality, we assume that the value $`R^𝒜`$ will determine the choice of faulty paths controlled by the adversary), and the coin flips $`R^𝒯`$ of all other honest nodes. Without loss of generality, we can assume that the protocol proceeds in steps, where $`A`$ is silent during even steps and $`B`$ is silent during odd steps (see ).

The strategy of the adversary is as follows. First it uses $`R^𝒜`$ to choose a value $`b`$. If $`b=0`$, then it uses $`R^𝒜`$ again to choose $`k`$ directed paths $`p_{a_1},\mathrm{},p_{a_k}`$ from $`A`$ to $`B`$ and controls the first node on each of these $`k`$ paths. If $`b=1`$, then it uses $`R^𝒜`$ again to choose $`ku`$ directed paths $`p_{a_1},\mathrm{},p_{a_{ku}}`$ from $`A`$ to $`B`$ and controls the first node on each of these $`ku`$ paths and the first node on each of the $`u`$ paths from $`B`$ to $`A`$. It also uses $`R^𝒜`$ to choose a message $`\widehat{M}^A𝐅`$ according to the same probability distribution from which the actual message $`M^A`$ was drawn. In the following we describe the protocol the adversary will follow.

* Case $`b=0`$. The $`k`$ paths $`p_{a_1},\mathrm{},p_{a_k}`$ behaves as a passive adversary. That is, it proceeds according to the protocol $`\mathrm{\Pi }`$.
* Case $`b=1`$. The $`ku`$ paths $`p_{a_1},\mathrm{},p_{a_{ku}}`$ ignores what $`A`$ sends in each step of the protocol and simulates what $`A`$ would send to $`B`$ when $`A`$ sending $`\widehat{M}^A`$ to $`B`$. The $`u`$ paths from $`B`$ ignores what $`B`$ sends in each step of the protocol and simulates what $`B`$ would send to $`A`$ when $`b=0`$.

In the following, we assume that the tuple $`(M^A,R^A,R^B,R^𝒯,R^𝒜)`$ is fixed, $`b=0`$, the protocol halts in $`l`$ steps, and the view of $`A`$ is $`view_\mathrm{\Pi }^A(M^A,R^A,R^B,R^𝒯,R^𝒜)`$. Let $`\alpha _{i,j}^A`$ be the values that $`A`$ sends on path $`p_i`$ in step $`j`$ and $`\stackrel{}{\alpha }_i^A=(\alpha _{i,1}^A,\mathrm{},\alpha _{i,l}^A)`$. We can view $`\stackrel{}{\alpha }_i^A`$ as shares of the message $`M^A`$. Similarly, let $`\alpha _{i,j}^B`$ be the values that $`B`$ receives on path $`p_i`$ in step $`j`$ and $`\stackrel{}{\alpha }_i^B=(\alpha _{i,1}^B,\mathrm{},\alpha _{i,l}^B)`$.

First, it is straightforward to show that for any $`k`$ paths $`p_{a_1},\mathrm{},p_{a_k}`$ from $`A`$ to $`B`$, there is an $`\widehat{R}_1^𝒜`$ such that $`b=0`$, the adversary controls the paths $`p_{a_1},\mathrm{},p_{a_k}`$, and

$$view_\mathrm{\Pi }^A(M^A,R^A,R^B,R^𝒯,R^𝒜)=view_\mathrm{\Pi }^A(M^A,R^A,R^B,R^𝒯,\widehat{R}_1^𝒜)$$
(1)
Due to the fact that $`\mathrm{\Pi }`$ is a perfectly private message transmission protocol, from any $`k`$ shares from $`(\stackrel{}{\alpha }_1^A,\stackrel{}{\alpha }_2^A,\mathrm{},\stackrel{}{\alpha }_{3k2u}^A)`$ one cannot recover the secret message $`M^A`$. Thus $`(\stackrel{}{\alpha }_1^A,\stackrel{}{\alpha }_2^A,\mathrm{},\stackrel{}{\alpha }_{3k2u}^A)`$ is at least a $`(k+1)`$-out-of-$`(3k2u)`$ secret sharing scheme.

Secondly, for any $`ku`$ paths $`p_{a_1},\mathrm{},p_{a_{ku}}`$ from $`A`$ to $`B`$, there is an $`\widehat{R}_2^𝒜`$ such that $`b=1`$, $`\widehat{M}^AM^A`$, the adversary controls the paths $`p_{a_1},\mathrm{},p_{a_{ku}},q_1,\mathrm{},q_u`$, and

$$view_\mathrm{\Pi }^A(M^A,R^A,R^B,R^𝒯,R^𝒜)=view_\mathrm{\Pi }^A(M^A,R^A,R^B,R^𝒯,\widehat{R}_2^𝒜)$$
(2)
Due to the fact that $`\mathrm{\Pi }`$ is a perfectly reliable message transmission protocol, any $`ku`$ errors in the shares $`(\stackrel{}{\alpha }_1^B,\stackrel{}{\alpha }_2^B,\mathrm{},\stackrel{}{\alpha }_{3k2u}^B)`$ can be corrected by $`B`$ to recover the secret message $`M^A`$.

In summary, $`(\stackrel{}{\alpha }_1^A,\stackrel{}{\alpha }_2^A,\mathrm{},\stackrel{}{\alpha }_{3k2u}^A)`$ is at least a $`(k+1)`$-out-of-$`(3k2u)`$ secret sharing scheme that can correct $`ku`$ errors. By the results in , we know that the maximum number of errors that a $`(k+1)`$-out-of-$`(3k2u)`$ secret sharing scheme could correct is

$$\frac{(3k2u)k1}{2}=\frac{2k2u1}{2}=ku1.$$

This is a contradiction, which concludes the proof. Q.E.D. $`\mathrm{}`$

For the sufficient condition, we first show the simple case for $`u=1`$.

###### Theorem 4.2

Let $`G(V,E)`$ be a directed graph, $`A,BV`$, and $`k2`$. If there are $`3k1`$ directed node disjoint paths $`p_1,\mathrm{},p_{3k1}`$ from $`A`$ to $`B`$ and one directed path $`q`$ from $`B`$ to $`A`$ ($`q`$ is node disjoint from $`p_1,\mathrm{},p_{3k1}`$) then there is a $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Proof. In the following protocol $`\pi `$, $`A`$ $`(0,0)`$-securely transmits $`M^A_R𝐅`$ to $`B`$:

* Both $`A`$ and $`B`$ sets $`I=1`$.
* $`A`$ constructs $`(k+1)`$-out-of-$`(3k1)`$ MDS secret shares $`(s_{1,I}^A,\mathrm{},s_{3k1,I}^A)`$ of $`M^A`$. For each $`1i3k1`$, $`A`$ sends $`s_{i,I}^A`$ to $`B`$ via the path $`p_i`$.
* For each $`i3k1`$, $`B`$ receives $`s_{i,I}^B`$ on path $`p_i`$. By correcting at most $`k1`$ errors, $`B`$ recovers a value $`\widehat{M}_I^B`$ from these shares. $`B`$ sends $`s_{I,I}^B`$ to $`A`$ via the path $`q`$.
* $`A`$ receives $`\overline{s}_{I,I}^A`$ from $`q`$. $`A`$ distinguishes the following two cases:

1. $`\overline{s}_{I,I}^A=s_{I,I}^A`$. $`A`$ reliably sends “path $`p_I`$ maybe OK”, sets $`I=I+1`$. If $`I>3k1`$ then goes to Step 6, otherwise, goes to Step 2.
    2. $`\overline{s}_{I,I}^As_{I,I}^A`$. $`A`$ reliably sends “path $`p_I`$ or $`q`$ is faulty”. $`A`$ constructs $`k`$-out-of-$`(3k2)`$ MDS secret shares $`\{r_{i,I}^A:iI,1i3k1\}`$ of $`M^A`$. For each $`i3k1`$ such that $`iI`$, $`A`$ sends $`r_{i,I}^A`$ to $`B`$ via the path $`p_i`$. $`A`$ terminates the protocol.
* $`B`$ distinguishes the following two cases:

1. $`B`$ reliably receives “path $`p_I`$ maybe OK”. $`B`$ sets $`I=I+1`$. If $`I>3k1`$ then goes to Step 6, otherwise, goes to Step 2.
    2. $`B`$ reliably receives “path $`p_I`$ or $`q`$ is faulty”. In this case, $`B`$ also receives $`r_{i,I}^B`$ from path $`p_i`$ for each $`iI`$. By correcting at most $`k1`$ errors, $`B`$ recovers $`M^B`$ from these shares and terminates the protocol.
* $`B`$ checks whether $`\widehat{M}_i^B=\widehat{M}_j^B`$ for all $`1i,j3k1`$. If all these values are equal, then $`B`$ sets $`M^B=\widehat{M}_1^B`$, sends “stop” to $`A`$ via $`q`$, and terminates the protocol. Otherwise, $`B`$ sends the shares $`(s_{1,3k1}^B,\mathrm{},s_{3k1,3k1}^B)`$ to $`A`$ via $`q`$.
* $`A`$ distinguishes the following two cases:

1. $`A`$ receives $`(\overline{s}_{1,3k1}^A,\mathrm{},\overline{s}_{3k1,3k1}^A)`$ on the path $`q`$. $`A`$ computes $`𝒫=\{i:\overline{s}_{i,3k1}^As_{i,3k1}^A\}`$, reliably sends $`𝒫`$ to $`B`$, and terminates the protocol.
    2. $`A`$ receives anything else. $`A`$ terminates the protocol.
* $`B`$ reliable receives $`𝒫`$ from $`A`$, recovers $`M^B`$ from the shares $`\{s_{i,3k1}^B:i𝒫\}`$, and terminates the protocol.

Since there could be $`k`$ faulty paths from $`A`$ to $`B`$, and a $`(k+1)`$-out-of-$`(3k1)`$ MDS secret sharing scheme can correct at most $`k1`$ errors and simultaneously detect $`k1`$ errors. $`B`$ may recover an incorrect message $`\widehat{M}_I^B`$ in Step 3. $`B`$ therefore needs to verify whether it has recovered the correct message in the following steps. Note that if $`q`$ is faulty, then $`B`$ must have recovered the correct message in Step 3 for each $`I`$. In Step 3, $`B`$ also sends $`s_{I,I}^B`$ to $`A`$ via the path $`q`$. This does not violate the perfect privacy property since if there are $`k1`$ faulty paths from $`A`$ to $`B`$, then the adversary gets at most $`k`$ shares including this share, and if there are $`k`$ faulty paths from $`A`$ to $`B`$, then the adversary does not control the path $`q`$ and does not get this share.

In Step 4, if $`\overline{s}_{I,I}^A=s_{I,I}^A`$, then it could be the case that $`s_{I,I}^B=s_{I,I}^A`$ or it could be the case that the path $`q`$ is faulty. In any case, we have to continue the protocol further. However, if $`\overline{s}_{I,I}^As_{I,I}^A`$, then $`A`$ is convinced that either $`p_I`$ or $`q`$ is faulty. Since a $`k`$-out-of-$`(3k2)`$ MDS secret sharing scheme could correct $`k1`$ errors and detect $`k1`$ errors simultaneously. $`B`$ will recover the correct message in Step 5.

Now assume that $`B`$ does not recover the correct message at the end of round $`I=3k1`$. We can distinguish the following two cases:

* $`B`$ recovers the same message $`\widehat{M}_I^B`$ in all $`3k1`$ rounds. If this happens, $`B`$ is convinced that this uniquely recovered message is the correct message. Note that this follows from the following two arguments: If the path $`q`$ is faulty, then obviously $`B`$ has recovered the same correct message in each round. If the path $`q`$ is non-faulty and we assume that the path $`p_t`$ ($`1t3k1`$) is faulty, then in order for the adversary to avoid being caught by $`A`$ in round $`t`$, $`p_t`$ must behave nicely in round $`t`$, that is, $`s_{t,t}^A=s_{t,t}^B`$ (otherwise $`A`$ has identified that $`q`$ or $`p_t`$ is faulty in round $`t`$). Thus there are at most $`k1`$ errors in the shares that $`B`$ received in round $`t`$ and $`B`$ recovers the correct message in round $`t`$.
* $`B`$ recovers different messages in these $`3k1`$ rounds. This happens only if $`q`$ is honest. Thus, $`B`$ could send the shares it receives in round $`3k1`$ to $`A`$ via path $`q`$ and $`A`$ can tell $`B`$ which shares are incorrect. Thus $`B`$ could recover the correct message from these non-faulty shares (there are at least $`2k1`$ non-faulty shares).

The above arguments show that the protocol $`\pi `$ is $`(0,0)`$-secure against a $`k`$-active adversary. Q.E.D. $`\mathrm{}`$

###### Theorem 4.3

Let $`G(V,E)`$ be a directed graph, $`A,BV`$, and $`k2`$. If there are $`n=\mathrm{max}\{3k+12u,2k+1\}`$ directed node disjoint paths $`p_1,\mathrm{},p_n`$ from $`A`$ to $`B`$ and $`u`$ directed path $`q_1,\mathrm{},q_u`$ from $`B`$ to $`A`$ ($`q_1,\mathrm{},q_u`$ are node disjoint from $`p_1,\mathrm{},p_n`$) then there is a $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Proof. For $`u=1`$ or $`k=2`$, the result is proved in Theorem 4.2. We prove the theorem by induction. Assume that $`u>1`$, $`k>2`$, and the theorem holds for $`u1`$ and $`k1`$. In the following, we show that the Theorem holds for $`u`$ and $`k`$ by induction.

Let $`=\{h_I:h_I=p_{I_1},\mathrm{},p_{I_u}\}`$ be the set of all ordered $`u`$-subsets of $`\{p_1,\mathrm{},p_n\}`$. Then $`||=\frac{n!}{(nu)!}`$. In the following protocol $`\pi `$, $`A`$ $`(0,0)`$-securely transmits $`M^A_R𝐅`$ to $`B`$:

* Both $`A`$ and $`B`$ set $`I=1`$.
* $`A`$ constructs $`(k+1)`$-out-of-$`n`$ MDS secret shares $`(s_{1,I}^A,\mathrm{},s_{n,I}^A)`$ of $`M^A`$. For each $`in`$, $`A`$ sends $`s_{i,I}^A`$ to $`B`$ via the path $`p_i`$.
* For each $`in`$, $`B`$ receives (or sets default) $`s_{i,I}^B`$ on path $`p_i`$. By correcting at most $`ku`$ errors, $`B`$ recovers a value $`\widehat{M}_I^B`$ from these shares. For each $`iu`$, $`B`$ sends $`s_{I_i,I}^B`$ to $`A`$ via the path $`q_i`$. Note that we assume $`h_I=p_{I_1},\mathrm{},p_{I_u}`$ here.
* For each $`iu`$, $`A`$ receives (or sets default) $`\overline{s}_{I_i,I}^A`$ from $`q_i`$. $`A`$ distinguishes the following two cases:

1. $`\overline{s}_{I_i,I}^A=s_{I_i,I}^A`$ for all $`iu`$. $`A`$ reliably sends “paths in $`h_I`$ maybe OK”, sets $`I=I+1`$. If $`I>||`$ then $`A`$ goes to Step 6, otherwise, goes to Step 2.
    2. $`\overline{s}_{I_{i_0},I}^As_{I_{i_0},I}^A`$ for some $`i_0u`$. $`A`$ reliably sends “path $`p_{I_{i_0}}`$ or $`q_{i_0}`$ is faulty”. $`A`$ goes to the $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:iI_{i_0}\}\{q_i:ii_0\}`$ to transmit $`M^A`$ to $`B`$ (here we use induction).
* $`B`$ distinguishes the following two cases:

1. $`B`$ reliably receives “paths in $`h_I`$ maybe OK”. $`B`$ sets $`I=I+1`$. If $`I>||`$ then goes to Step 6, otherwise, goes to Step 2.
    2. $`B`$ reliably receives “path $`p_{I_{i_0}}`$ or $`q_{i_0}`$ is faulty”. In this case, $`B`$ goes to the $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:iI_{i_0}\}\{q_i:ii_0\}`$ and receives the message $`M^B`$.
* $`B`$ computes whether $`\widehat{M}_i^B=\widehat{M}_j^B`$ for all $`i,j||`$. If all these values are equal, then $`B`$ sets $`M^B=\widehat{M}_1^B`$, sends “stop” to $`A`$ via all paths $`q_i`$, and terminates the protocol. Otherwise, $`B`$ goes to Step 8.
* If $`A`$ receives “stop” on all paths $`q_1,\mathrm{},q_u`$, then $`A`$ terminates the protocol, otherwise, $`A`$ goes to Step 8.
* $`A`$ chooses $`R_1^A_R𝐅`$, constructs $`(k+1)`$-out-of-$`n`$ MDS secret shares $`(s_1^A,\mathrm{},s_n^A)`$ of $`R_1^A`$, and sends $`s_i^A`$ to $`B`$ via path $`p_i`$ for each $`in`$.
* For each $`in`$, $`B`$ receives (or sets default) $`s_i^B`$ on path $`p_i`$. $`B`$ distinguishes the following two cases:

1. There are errors in the shares $`(s_1^B,\mathrm{},s_n^B)`$. In this case, for each $`ju`$, $`B`$ sends $`(s_1^B,\mathrm{},s_n^B)`$ to $`A`$ via the path $`q_j`$. Note that a $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme could be used to detect $`nk1k`$ errors.
    2. There is no error in the shares $`(s_1^B,\mathrm{},s_n^B)`$. $`B`$ recovers the value $`R_1^B`$ from these shares and for each $`ju`$, $`B`$ sends “OK” to $`A`$ via path $`q_j`$.
* For each $`ju`$, $`A`$ receives (or sets default) $`(\overline{s}_{1,j}^A,\mathrm{},\overline{s}_{n,j}^A)`$ from the path $`q_j`$. $`A`$ distinguishes the following two cases:

1. $`\overline{s}_{i_0,j_0}^As_{i_0}^A`$ for some $`i_0n`$ and $`j_0u`$. $`A`$ reliably sends “path $`p_{i_0}`$ or $`q_{j_0}`$ is faulty” to $`B`$. $`A`$ goes to the $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:ii_0\}\{q_j:jj_0\}`$ to transmit $`M^A`$ to $`B`$ (here we use induction again).
    2. All other cases. $`A`$ reliably transmits “continue the protocol” to $`B`$ and goes to Step 12.
* $`B`$ distinguishes the following two cases:

1. $`B`$ reliably receives “continue the protocol”. $`B`$ goes to Step 12.
    2. $`B`$ reliably receives “path $`p_{i_0}`$ or $`q_{j_0}`$ is faulty”. In this case, $`B`$ goes to the $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:ii_0\}\{q_j:jj_0\}`$ and receives the message $`M^B`$.
* $`A`$ computes $`R_2^A=M^AR_1^A`$, constructs $`(k+1)`$-out-of-$`n`$ MDS secret shares $`(s_1^A,\mathrm{},s_n^A)`$ of $`R_2^A`$, and sends $`s_i^A`$ to $`B`$ via path $`p_i`$ for each $`in`$.
* For each $`in`$, $`B`$ receives (or sets default) $`s_i^B`$ on path $`p_i`$. $`B`$ distinguishes the following two cases:

1. There are errors in the shares $`(s_1^B,\mathrm{},s_n^B)`$. In this case, for each $`ju`$, $`B`$ sends $`(s_1^B,\mathrm{},s_n^B)`$ to $`A`$ via the path $`q_j`$.
    2. There is no error in the shares $`(s_1^B,\mathrm{},s_n^B)`$. $`B`$ recovers the value $`R_2^B`$ from these shares, computes the secret $`M^B=R_1^B+R_2^B`$, and for each $`ju`$, $`B`$ sends “OK” to $`A`$ via path $`q_j`$. $`B`$ terminates the protocol.
* For each $`ju`$, $`A`$ receives (or sets default) $`(\overline{s}_{1,j}^A,\mathrm{},\overline{s}_{u,j}^A)`$ from the path $`q_j`$. $`A`$ distinguishes the following two cases:

1. $`\overline{s}_{i_0,j_0}^As_{i_0}^A`$ for some $`i_0n`$ and $`j_0u`$. $`A`$ reliably sends “path $`p_{i_0}`$ or $`q_{j_0}`$ is faulty” to $`B`$. $`A`$ goes to the $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:ii_0\}\{q_j:jj_0\}`$ to transmit $`M^A`$ to $`B`$.
    2. All other cases. $`A`$ reliably transmits “the protocol is complete” to $`B`$ and terminates the protocol.
* $`B`$ distinguishes the following two cases:

1. $`B`$ reliably receives “the protocol is complete”. $`B`$ terminates the protocol.
    2. $`B`$ reliably receives “path $`p_{i_0}`$ or $`q_{j_0}`$ is faulty”. In this case, $`B`$ goes to the $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:ii_0\}\{q_j:jj_0\}`$ and receives the message $`M^B`$.

Since there could be $`k`$ faulty paths from $`A`$ to $`B`$, and a $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme in Steps 2 and 3 can correct at most $`ku`$ errors and simultaneously detect $`ku`$ errors. $`B`$ may recover an incorrect message $`\widehat{M}_I^B`$ in Step 3. $`B`$ therefore needs to verify whether it has recovered the correct message in the following steps. Note that if all the paths from $`B`$ to $`A`$ are faulty, then $`B`$ must have recovered the correct message in Step 3 for each $`I||`$. In Step 3, $`B`$ also sends $`s_{I_i,I}^B`$ to $`A`$ via the path $`q_i`$. This will not violate the perfect privacy property since if there are $`t`$ faulty paths from $`B`$ to $`A`$, then the adversary gets $`kt`$ shares from the $`A`$ to $`B`$ paths and $`t`$ shares from the $`B`$ to $`A`$ paths. That is, the adversary gets at most $`k`$ shares.

In Step 4, if $`\overline{s}_{I_i,I}^A=s_{I_i,I}^A`$ for all $`iu`$, then for each $`iu`$, it could be the case that $`s_{I_i,I}^B=s_{I_i,I}^A`$ or it could be the case that the path $`q_i`$ is faulty. In any case, we have to continue the protocol further. However, if $`\overline{s}_{I_{i_0},I}^As_{I_{i_0},I}^A`$ for some $`i_0u`$, then $`A`$ is convinced that either $`p_{I_{i_0}}`$ or $`q_{i_0}`$ is faulty. Thus if we delete the two paths $`p_{I_{i_0}}`$ and $`q_{i_0}`$, we have at most $`k1`$ unknown faulty paths, $`n1`$ paths from $`A`$ to $`B`$, and $`u1`$ paths from $`B`$ to $`A`$. Since

$$\begin{array}{ccc}\mathrm{max}\{3(k1)+12(u1),2(k1)+1\}\hfill & =\hfill & \mathrm{max}\{3k2u4,2k1\}\hfill \\ & \hfill & \mathrm{max}\{3k2u,2k\}\hfill \\ & =\hfill & n1,\hfill \end{array}$$

there is (by induction) a $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`(k1)`$-active adversary on the paths $`\{p_i:iI_{i_0}\}\{q_i:ii_0\}`$, $`B`$ recovers the correct message $`M^B`$ in Step 5.

Assume that $`B`$ does not recover the correct message at the beginning of Step 6. If $`B`$ recovers the same value $`\widehat{M}_I^B`$ in all the $`||`$ rounds between Step 2 and Step 5, then $`B`$ is convinced that this uniquely recovered value is the correct message. Note that this follows from the following arguments:

* All paths $`q_1,\mathrm{},q_u`$ from $`B`$ to $`A`$ are faulty. In this case $`B`$ obviously has recovered the correct message in each round.
* There is non-faulty path from $`B`$ to $`A`$. In this case, let $`t1`$, $`q_{i_1},\mathrm{},q_{i_t}`$ be a list of all non-faulty paths from $`B`$ to $`A`$, $`p_{j_1},\mathrm{},p_{j_t}`$ be faulty, and $`h_I=p_{I_1},\mathrm{},p_{I_u}`$ with $`I_{i_1}=j_1,\mathrm{},I_{i_t}=j_t`$. If $`(s_{1,I}^B,\mathrm{},s_{n,I}^B)`$ is the shares that $`B`$ receives in Step 3 of round $`I`$, then $`s_{j_1,I}^B=s_{j_1,I}^A`$, $`\mathrm{}`$, $`s_{j_t,I}^B=s_{j_t,I}^A`$ (otherwise $`A`$ identifies that some $`q_i`$ or $`p_j`$ is faulty in round $`I`$). That is, there are at most $`ku`$ errors in the shares $`(s_{1,I}^B,\mathrm{},s_{n,I}^B)`$, and $`B`$ recovers the correct secret message in round $`I`$.

Now assume that $`B`$ does not recover the correct message at the beginning of Step 6 and $`B`$ recovers different values in these $`||`$ rounds between Step 2 and Step 5. If this happens, then there must be non-faulty paths from $`B`$ to $`A`$. In this case, both $`A`$ and $`B`$ continues the protocol from Step 8. During Step 8 and Step 15, $`A`$ tries to send $`R_1^A`$ and $`R_2^A`$ to $`B`$ using the $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme. Since there are at most $`k`$ faulty paths, and a $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme could be used to correct $`0`$ error and simultaneously detect at least $`k`$ errors, any error in these shares could be detected by $`B`$ in Steps 9 and 13. Since there are non-faulty paths from $`B`$ to $`A`$, any errors in these shares will be reported back $`A`$ via the non-faulty $`B`$ to $`A`$ paths. Thus $`A`$ initiates a $`(0,0)`$-secure message transmission protocol against a $`(k1)`$-active adversary on the paths $`\{p_i:ii_0\}\{q_j:jj_0\}`$ in Step 10 or Step 14 and $`B`$ will receive the secret. If any error occurs in these cases, $`B`$ reports either the shares of $`R_1^A`$ or the shares of $`R_2^A`$ (but not both) to $`A`$ via the $`B`$ to $`A`$ paths. Thus we have achieved the perfect privacy here. On the other hand, if there is no error in these shares of $`R_1^A`$ and $`R_2^A`$, then $`B`$ recovers the correct secret $`M^B=R_1^B+R_2^B`$.

We therefore proved that the protocol $`\pi `$ is $`(0,0)`$-secure against a $`k`$-active adversary. Q.E.D. $`\mathrm{}`$

In Theorem 4.3, we have the restriction that $`k2`$. In the following we show a sufficient condition which is applicable to $`k=1`$.

###### Theorem 4.4

Let $`G(V,E)`$ be a directed graph, $`A,BV`$. If there are $`3k`$ directed node disjoint paths $`p_1,\mathrm{},p_{3k}`$ from $`A`$ to $`B`$ and one directed path $`q`$ from $`B`$ to $`A`$ ($`q`$ is node disjoint from $`p_1,\mathrm{},p_{3k}`$) then there is a $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Proof. In the following protocol $`\pi `$, $`A`$ $`(0,0)`$-securely transmits $`M^A_R𝐅`$ to $`B`$.

* $`A`$ constructs $`(k+1)`$-out-of-$`3k`$ MDS secret shares $`v^A=(s_1^A,\mathrm{},s_{3k}^A)`$ of $`M^A`$. For each $`1i3k`$, $`A`$ sends $`s_i`$ to $`B`$ via the path $`p_i`$.
* Let $`v^B=(s_1^B,\mathrm{},s_{3k}^B)`$ be the shares $`B`$ receives. If $`B`$ finds that there are at most $`k1`$ errors, $`B`$ recovers $`M^B`$ from the shares, sends “stop” to $`A`$ via the path $`q`$, and terminates the protocol. Otherwise there are $`k`$ errors. In this case $`B`$ sends $`v^B`$ back to $`A`$ via the path $`q`$ (note that $`q`$ is an honest path in this case).
* $`A`$ distinguishes the following two cases:

1. $`A`$ receives $`\overline{v}^A=(\overline{s}_1^A,\mathrm{},\overline{s}_{3k}^A)`$ from the path $`q`$. $`A`$ reliably sends $`𝒫=\{i:s_i^A\overline{s}_i^A\}`$ to $`B`$.
    2. $`A`$ received “stop” or anything else via $`q`$. $`A`$ terminates the protocol.
* $`B`$ reliably receives $`𝒫`$ from $`A`$. $`B`$ recovers $`M^B`$ from the shares $`\{s_i^B:i𝒫\}`$ and terminates the protocol (note that $`|\{s_i^B:i𝒫\}|=2k`$).

Note that if $`B`$ sends $`v^B`$ to $`A`$ in Step 2 then $`k`$ paths from $`A`$ to $`B`$ are corrupted and the path $`q`$ is honest. Thus the adversary will not learn $`v^B`$. If the adversary controls the path $`q`$, then it may change the message “stop” to something else. In this case, $`A`$ will not be able to identify the corrupted paths from $`A`$ to $`B`$. However, since $`B`$ has already recovered the key, $`B`$ will just ignore the next received message. It is straightforward to show that the protocol is $`(0,0)`$-secure. Q.E.D. $`\mathrm{}`$

## 5 Efficient $`(0,0)`$-secure message transmission in directed graphs

In the previous section, we proved a necessary and sufficient condition for $`(0,0)`$-secure message transmission from $`A`$ to $`B`$. Our protocols in these proofs are not efficient (exponential in $`k`$). In this section, we show that if there are totally $`3k+1`$ paths between $`A`$ and $`B`$, then there are efficient (linear in $`u`$) $`(0,0)`$-secure message transmission protocols from $`A`$ to $`B`$.

###### Theorem 5.1

Let $`G(V,E)`$ be a directed graph, $`A,BV`$ and $`ku`$. If there are $`n=3k+1u`$ directed node disjoint paths $`p_1,\mathrm{},p_n`$ from $`A`$ to $`B`$ and $`u`$ directed node disjoint paths $`q_1,\mathrm{},q_u`$ from $`B`$ to $`A`$ ($`q_1,\mathrm{},q_u`$ are node disjoint from $`p_1,\mathrm{},p_n`$) then there is an efficient $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Proof. If we replace the steps between Step 1 and Step 7 of the protocol $`\pi `$ in the proof of Theorem 4.3 with the following steps:

* $`A`$ constructs $`(k+1)`$-out-of-$`n`$ MDS secret shares $`(s_1^A,\mathrm{},s_n^A)`$ of $`M^A`$. For each $`in`$, $`A`$ sends $`s_i^A`$ to $`B`$ via the path $`p_i`$.
* For each $`in`$, $`B`$ receives (or sets default) $`s_i^B`$ on path $`p_i`$. If there are at most $`ku`$ errors in the shares $`(s_1^B,\mathrm{},s_n^B)`$, then $`B`$ recovers the secret message $`M^B`$ from these shares by correcting the errors, sends “stop” to $`A`$ via all paths $`q_i`$, and terminates the protocol. Otherwise, $`B`$ sends “continue the protocol” to $`A`$ via all paths $`q_i`$ and goes to Step 8 of the protocol $`\pi `$.
* If $`A`$ receives “stop” on all paths $`q_1,\mathrm{},q_u`$, then $`A`$ terminates the protocol, otherwise, $`A`$ goes to Step 8 of the protocol $`\pi `$.

Note that a $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme could be used to detect $`k`$ errors and simultaneously correct $`ku`$ errors. Thus if all the paths $`q_1,\mathrm{},q_u`$ are controlled by the adversary, then $`B`$ recovers the secret message $`M^B`$ in Step 2. If at least one path from $`B`$ to $`A`$ is not controlled by the adversary, then the protocol $`\pi `$ in the proof of Theorem 4.3 starting from Step 8 will let $`B`$ to recover the secret message $`M^B`$. Here we should also note that the induction initiated in Step 10 or Step 14 of the protocol $`\pi `$ works since $`3k+1u1=3ku>3(k1)+1(u1)`$. It is straightforward that the protocol will terminates in at most $`11u`$ steps. Q.E.D. $`\mathrm{}`$

In the previous theorems, including Theorem 5.1, we have the restriction that the directed paths from $`B`$ to $`A`$ are all node disjoint from the directed paths from $`A`$ to $`B`$. In the following theorem we partially remove this restriction.

###### Theorem 5.2

Let $`G(V,E)`$ be a directed graph, $`A,BV`$. Assume that there are $`n=3k+1u2k+1`$ (which implies $`ku`$) directed node disjoint paths $`p_1,\mathrm{},p_n`$ from $`A`$ to $`B`$ and $`u`$ node disjoint directed paths $`q_1,\mathrm{},q_u`$ from $`B`$ to $`A`$. If $`3k+12u`$ paths among these $`3k+1u`$ paths from $`A`$ to $`B`$ are node disjoint from the $`u`$ paths from $`B`$ to $`A`$, then there is an efficient $`(0,0)`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Proof. We note that the proof of Theorem 5.1 could not be used here since if we remove (in the induction step) two paths $`p_i`$ and $`q_j`$ such that one of them is corrupted, we are not guaranteed that the $`k`$-active adversary becomes a $`(k1)`$-active adversary ($`q_j`$ may share a node with some other directed paths from $`A`$ to $`B`$ and that node could be corrupted).

First we describe the proof informally. The protocol is divided into two phases. In phase one of the protocol, $`A`$ tries to transmit the secret message to $`B`$ assuming at least one of the directed paths from $`B`$ to $`A`$ is not corrupted. This is done by running $`u`$ concurrent sub-protocols in phase one, in each sub-protocol $`B`$ uses one of the directed paths from $`B`$ to $`A`$ to send some feedback information to $`A`$. In the second phase of the protocol, $`A`$ transmits shares of the secret message through the $`A`$ to $`B`$ paths excluding these paths which have intersection with $`B`$ to $`A`$ paths. $`B`$ will use the information received in the second phase only if $`B`$ detects that all directed paths from $`B`$ to $`A`$ are corrupted in phase one.

In phase one, $`A`$ and $`B`$ execute the following protocol on the path set $`\{p_i:1in\}\{q\}`$ for each directed path $`q`$ from $`B`$ to $`A`$. First $`A`$ chooses $`R_0_R𝐅`$ and sends shares of $`R_0`$ to $`B`$ via the paths $`p_1,\mathrm{},p_n`$ using a $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme. If $`B`$ can correct the errors in the received shares (that is, there were at most $`ku`$ errors), $`B`$ recovers $`R_0`$. Otherwise $`B`$ needs help from $`A`$ and $`B`$ sends the received shares back to $`A`$ via the $`B`$ to $`A`$ path $`q`$. The problems are that: $`B`$ may receive help even if $`B`$ has never asked for. However $`B`$ can detect this. Therefore $`B`$ always works with $`A`$ on such a protocol and recovers the correct $`R_0`$. Then $`A`$ sends $`R_1=M^AR_0`$ using a $`(k+1)`$-out-of-$`n`$ MDS secret sharing scheme. If $`B`$ can correct the errors in the received shares of $`R_1`$, $`B`$ has found the secret and can terminate the protocol. If $`B`$ cannot correct these errors, $`B`$ needs to continue the protocol. In this situation, $`B`$ distinguishes the following two cases:

1. $`B`$ has not asked for help in the transmission of $`R_0`$. $`B`$ can ask for help now and $`B`$ will then recover the secret $`M^A`$.
2. $`B`$ has asked for help in the transmission of $`R_0`$. In this case $`B`$ cannot ask for help (otherwise the adversary may learn both the values of $`R_0`$ and $`R_1`$ and thus may recover the secret). The sub-protocol needs to be restarted (that is, $`A`$ constructs different $`R_0`$ and $`R_1`$ for $`M^A`$ and sends them to $`B`$ again). Each time when $`A`$ and $`B`$ restart this sub-protocol, $`A`$ sends the shares of $`R_0`$ and $`R_1`$ only via these “non-corrupted” paths from $`A`$ to $`B`$. The “non-corrupted” paths are computed from the feedbacks that $`A`$ has received from the path $`q`$. If $`q`$ is not corrupted, then the computation is reliable. However, if $`q`$ is corrupted, then the computation is unreliable. If there is at least one non-corrupted path $`q_{i_0}`$ from $`B`$ to $`A`$, then $`B`$ recovers the secret from the sub-protocol running on the path set $`\{p_1,\mathrm{},p_n\}\{q_{i_0}\}`$. Otherwise $`B`$ cannot recover the secret in phase one and we will go to phase two.

If $`B`$ asks for help in the transmission of $`R_0`$, then both $`A`$ and $`B`$ “identify” the corrupted paths from $`A`$ and $`B`$ according to the information that $`B`$ sends to $`A`$ via the path $`q`$. If $`k^{}`$ dishonest paths from $`A`$ to $`B`$ have been (correctly or incorrectly) identified at the restart of the sub-protocol, $`A`$ uses a $`(k+1)`$-out-of-$`(3k+1uk^{})`$ MDS secret sharing scheme. This MDS secret sharing scheme will only be used for error detection (or message recovery in the case that no error occurs), thus it can be used to detect $`3k+1uk^{}k1=2kuk^{}kk^{}`$ errors. Due to the fact that this MDS secret sharing scheme cannot detect $`k`$ errors we need to organize ourselves that $`B`$ will never use incorrectly identified paths from $`A`$ to $`B`$ since otherwise $`B`$ could compute the incorrect “secret”. This is easy to be addressed by having $`B`$ detect whether the path $`q`$ from $`B`$ to $`A`$ is dishonest or not. This is done by having $`A`$ reliably send to $`B`$ what $`A`$ received via the path $`q`$. Since a $`(k+1)`$-out-of-$`(3k+1u)`$ MDS secret sharing scheme can detect $`k`$ errors and simultaneously correct $`ku`$ errors, both $`A`$ and $`B`$ identify at least $`k^{}ku+1`$ dishonest paths from $`A`$ to $`B`$ in the first run of the sub-protocol. During each following run of the sub-protocol, $`B`$ will either recover the secret message (when no error occurs) or detect at least one corrupted path from $`A`$ to $`B`$ ($`A`$ could also detect the corrupted path from $`A`$ to $`B`$ according to the information $`A`$ received on the path $`q`$). Thus the sub-protocol will be restarted at most $`u`$ times.

In phase two of the protocol, $`A`$ constructs $`(k+1)`$-out-of-$`(3k+12u)`$ MDS shares $`(s_1,\mathrm{},s_{3k+12u})`$ of the secret $`M^A`$ and sends these shares to $`B`$ via the $`3k+12u`$ paths which are node disjoint from the paths from the $`u`$ paths from $`B`$ to $`A`$. Note that if $`B`$ has determined that all these $`u`$ paths from $`B`$ to $`A`$ have been corrupted in phase one, then $`B`$ recovers the secret $`M^A`$ from the received shares $`(s_1^B,\mathrm{},s_{3k+12u}^B)`$ in phase two since a $`(k+1)`$-out-of-$`(3k+12u)`$ MDS secret sharing scheme can be used to detect and correct $`ku`$ errors simultaneously. Note that if at least one path from $`B`$ to $`A`$ is honest in phase one, then $`B`$ has recovered the secret in phase and can just ignore this last message.

Now we present the entire protocol formally.

* $`B`$ sets $`\mathrm{BA}\mathrm{\_}\mathrm{BAD}=\mathrm{}`$. For each directed path $`q`$ from $`B`$ to $`A`$, $`A`$ and $`B`$ run the sub-protocol between Step 2 and Step 11 (the sup-protocols for the $`u`$ paths could be run parallely).
* $`A`$ sets $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A=\{p_1,\mathrm{},p_n\}`$ and $`j^A=0`$. $`B`$ sets $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B=\{p_1,\mathrm{},p_n\}`$ and $`j^B=0`$.
* Let $`n_j=|\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A|`$. $`A`$ chooses $`R_0_R𝐅`$, and constructs $`(k+1)`$-out-of-$`n_j`$ MDS secret shares $`\{s_i^A:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\}`$ of $`R_0`$. For each $`p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A`$, $`A`$ sends $`s_i^A`$ to $`B`$ via the path $`p_i`$.
* For each $`p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B`$, $`B`$ receives $`s_i^B`$ from $`A`$ via the path $`p_i`$. $`B`$ distinguishes the following two cases:

1. $`B`$ can recover $`R_0`$. If $`j=0`$ and there are at most $`ku`$ errors, $`B`$ recovers $`R_0`$ by correcting the errors (note that a $`(k+1)`$-out-of-$`n`$ MDS scheme can be used to detect $`k`$ errors and simultaneously correct $`ku`$ errors). If $`j>0`$, then $`B`$ recovers $`R_0`$ only if there is no error in the received shares. $`B`$ sends “ok” to $`A`$ via the path $`q`$.
    2. $`B`$ cannot recover $`R_0`$. $`B`$ sends $`\{s_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\}`$ to $`A`$ via the path $`q`$.
* $`A`$ distinguishes the following two cases:

1. $`A`$ receives “ok” via the path $`q`$. $`A`$ reliably sends “ok” to $`B`$.
    2. $`A`$ receives $`\{\overline{s}_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\}`$ (or sets default values if the received values are not in valid format). $`A`$ sets $`\mathrm{BAD}^A=\{p_i:\overline{s}_i^Bs_i^A\}`$ and reliably sends $`\{\overline{s}_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\}`$ and $`\mathrm{BAD}^A`$ to $`B`$. $`A`$ sets $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A=\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\mathrm{BAD}^A`$,
* $`B`$ distinguishes the following two cases:

1. $`B`$ reliably receives “ok” from $`A`$. If $`B`$ sent “ok” to $`A`$ in the Step 4, then goes to Step 7. Otherwise, $`B`$ sets $`\mathrm{BA}\mathrm{\_}\mathrm{BAD}=\mathrm{BA}\mathrm{\_}\mathrm{BAD}\{q\}`$ and goes to Step 11.
    2. $`B`$ reliably receives $`\{\overline{s}_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\}`$ and $`\mathrm{BAD}^B`$ from $`A`$. If $`\overline{s}_i^B=s_i^B`$ for all $`p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B`$, then $`B`$ sets $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B=\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\mathrm{BAD}^B`$, recovers $`R_0`$ from $`\{s_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\}`$, and goes to Step 7. Otherwise, $`B`$ sets $`\mathrm{BA}\mathrm{\_}\mathrm{BAD}=\mathrm{BA}\mathrm{\_}\mathrm{BAD}\{q\}`$ and goes to Step 11.
* Let $`n_j=|\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A|`$. $`A`$ constructs $`(k+1)`$-out-of-$`n_j`$ MDS secret shares $`\{s_i^A:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\}`$ of $`R_1=M^AR_0`$. For each $`p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A`$, $`A`$ sends $`s_i^A`$ to $`B`$ via the path $`p_i`$.
* For each $`p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B`$, $`B`$ receives $`s_i^B`$ from $`A`$ via the path $`p_i`$. $`B`$ distinguishes the following two cases:

1. $`B`$ can recover $`R_1`$. $`B`$ recovers $`R_1`$ only if there is no error in the received shares. $`B`$ sends “ok” to $`A`$ via the path $`q`$.
    2. $`B`$ cannot recover $`R_1`$. For this situation we need to distinguish two cases:

    1. $`B`$ sent “ok” to $`A`$ in Step 4. That is, $`B`$ has not asked for help to recover $`R_0`$. Then $`B`$ can ask for help now. $`B`$ sends $`\{s_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\}`$ to $`A`$ via the path $`q`$.
        2. $`B`$ sent the received shares to $`A`$ in Step 4. That is, $`B`$ has asked for help to recover $`R_0`$. Then $`B`$ cannot ask for help now. $`B`$ sends “continue to the next round” to $`A`$ via the path $`q`$.
* $`A`$ distinguishes the following three cases:

1. $`A`$ receives “ok” via the path $`q`$. $`A`$ reliably sends “ok” to $`B`$.
    2. $`A`$ receives “continue to the next round” via the path $`q`$. $`A`$ sets $`j^A=j^A+1`$, reliably sends “continue to the next round” to $`B`$, and goes to Step 3.
    3. $`A`$ receives $`\{\overline{s}_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\}`$ (or sets default values if the received values are in invalid format). $`A`$ sets $`\mathrm{BAD}^A=\{p_i:\overline{s}_i^Bs_i^A\}`$, $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A=\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\mathrm{BAD}^A`$, and reliably sends $`\{\overline{s}_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A\}`$ and $`\mathrm{BAD}^A`$ to $`B`$.
* $`B`$ distinguishes the following three cases:

1. $`B`$ reliably receives “ok” from $`A`$. If $`B`$ sent “ok” to $`A`$ in the Step 8, then $`B`$ has recovered the secret. $`B`$ terminates the entire protocol. Otherwise, $`B`$ sets $`\mathrm{BA}\mathrm{\_}\mathrm{BAD}=\mathrm{BA}\mathrm{\_}\mathrm{BAD}\{q\}`$ and goes to Step 11.
    2. $`B`$ reliably receives “continues to the next round”. If $`B`$ sent “continues to the next round” to $`A`$ in the Step 8, then $`B`$ sets $`j^B=j^B+1`$ and goes to Step 3. Otherwise, $`B`$ sets $`\mathrm{BA}\mathrm{\_}\mathrm{BAD}=\mathrm{BA}\mathrm{\_}\mathrm{BAD}\{q\}`$ and goes to Step 11.
    3. $`B`$ reliably receives $`\{\overline{s}_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\}`$ and $`\mathrm{BAD}^B`$ from $`A`$. If $`\overline{s}_i^B=s_i^B`$ for all $`p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B`$, then $`B`$ sets $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B=\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\mathrm{BAD}^B`$, recovers $`R_1`$ from $`\{s_i^B:p_i\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B\}`$, recovers the secret $`M^B`$ from both $`R_0`$ and $`R_1`$, and terminates the entire protocol. Otherwise, $`B`$ sets $`\mathrm{BA}\mathrm{\_}\mathrm{BAD}=\mathrm{BA}\mathrm{\_}\mathrm{BAD}\{q\}`$ and goes to Step 11.
* $`B`$ waits until all $`u`$ sub-protocols in phase one finish. If $`|\mathrm{BA}\mathrm{\_}\mathrm{BAD}|=u`$ then $`B`$ goes to Step 12. Otherwise, $`B`$ has recovered the secret message, thus terminates the entire protocol.
* $`A`$ constructs $`(k+1)`$-out-of-$`(3k+12u)`$ MDS shares $`(s_1,\mathrm{},s_{3k+12u})`$ of the secret $`M^A`$ and sends these shares to $`B`$ via the $`3k+12u`$ paths which are node disjoint from the $`u`$ $`B`$ to $`A`$ paths. Note that if $`|\mathrm{BA}\mathrm{\_}\mathrm{BAD}|=u`$, then $`B`$ can recover the secret message $`M^B`$ from the received shares $`(s_1^B,\mathrm{},s_{3k+12u}^B)`$ since a $`(k+1)`$-out-of-$`(3k+12u)`$ MDS secret sharing scheme can be used to detect and correct $`ku`$ errors simultaneously.

It is straightforward to show that at the beginning of each run of the sub-protocol between Step 2 and Step 11, Both $`A`$ and $`B`$ have the same sets of $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}`$, that is, $`\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^A=\mathrm{AB}\mathrm{\_}\mathrm{CHANNEL}^B`$ at Step 2. From the analysis before the above protocol, it is straightforward that the above protocol is a $`(0,0)`$-secure message transmission protocol against a $`k`$-active adversary. Q.E.D. $`\mathrm{}`$

## 6 Secure message transmissions in hypergraphs

Applications of hypergraphs in secure communications have been studied by Franklin and Yung in . A hypergraph $`H`$ is a pair $`(V,E)`$ where $`V`$ is the node set and $`E`$ is the hyperedge set. Each hyperedge $`eE`$ is a pair $`(A,A^{})`$ where $`AV`$ and $`A^{}`$ is a subset of $`V`$. In a hypergraph, we assume that any message sent by a node $`A`$ will be received identically by all nodes in $`A^{}`$, whether or not $`A`$ is faulty, and all parties outside of $`A^{}`$ learn nothing about the content of the message.

Let $`A,BV`$ be two nodes of the hypergraph $`H(V,E)`$. We say that there is a “direct link” from node $`A`$ to node $`B`$ if there exists a hyperedge $`(A,A^{})`$ such that $`BA^{}`$. We say that there is an “undirected link” from $`A`$ to $`B`$ if there is a directed link from $`A`$ to $`B`$ or a directed link from $`B`$ to $`A`$. If there is a directed (undirected) link from $`A_i`$ to $`A_{i+1}`$ for every $`i`$, $`0i<k`$, then we say that there is a “directed path” (“undirected path”) from $`A_0`$ to $`A_k`$. $`A`$ and $`B`$ are “strongly $`k`$-connected” (“weakly $`k`$-connected”) in the hypergraph $`H(V,E)`$ if for all $`SV\{A,B\}`$, $`|S|<k`$, there remains a directed (undirected) path from $`A`$ to $`B`$ after the removal of $`S`$ and all hyperedges $`(X,X^{})`$ such that $`S(X^{}\{X\})\mathrm{}`$. Franklin and Yung  showed that reliable and private communication from $`A`$ to $`B`$ is possible against a $`k`$-passive adversary if and only if $`A`$ and $`B`$ are strongly 1-connected and weakly $`(k+1)`$-connected. It should be noted that $`B`$ and $`A`$ are strongly $`k`$-connected does not necessarily mean that $`A`$ and $`B`$ are strongly $`k`$-connected.

Following Franklin and Yung , and, Franklin and Wright , we consider multicast as our only communication primitive in this section. A message that is multicast by any node $`A`$ in a hypergraph is received by all nodes $`A^{}`$ with privacy (that is, nodes not in $`A^{}`$ learn nothing about what was sent) and authentication (that is, nodes in $`A^{}`$ are guaranteed to receive the value that was multicast and to know which node multicast it). We assume that all nodes in the hypergraph know the complete protocol specification and the complete structure of the hypergraph.

###### Definition 6.1

Let $`H(V,E)`$ be a hypergraph, $`A,BV`$ be distinct nodes of $`H`$, and $`k0`$. $`A`$, $`B`$ are $`k`$-separable in $`H`$ if there is a node set $`WV`$ with at most $`k`$ nodes such that any directed path from $`A`$ to $`B`$ goes through at least one node in $`W`$. We say that $`W`$ separates $`A,B`$.

Remark. Note that there is no straightforward relationship between strong connectivity and separability in hypergraphs.

###### Theorem 6.2

Let $`H(V,E)`$ be a hypergraph, $`A,BV`$ be distinct nodes of $`H`$, and $`k0`$. The nodes $`A`$ and $`B`$ are not $`2k`$-separable if and only if there are $`2k+1`$ directed node disjoint paths from $`A`$ to $`B`$ in $`H`$.

Proof. This follows directly from the maximum-flow minimum-cut theorem in classical graph theory. For details, see, e.g., . Q.E.D. $`\mathrm{}`$

###### Theorem 6.3

Let $`H(V,E)`$ be a hypergraph, $`A,BV`$ be distinct nodes of $`H`$, and $`k0`$. A necessary and sufficient condition for reliable message transmission from $`A`$ to $`B`$ against a $`k`$-active adversary is that $`A`$ and $`B`$ are not $`2k`$-separable in $`H`$.

Proof. First assume that $`A`$ and $`B`$ cannot be separated by a $`2k`$-node set. By Theorem 6.2, there are $`2k+1`$ directed node disjoint paths from $`A`$ to $`B`$ in $`H`$. Thus reliable message transmission from $`A`$ to $`B`$ is possible.

Next assume that $`A`$ and $`B`$ can be separated by a $`2k`$-node set $`W`$ in $`H`$. We shall show that reliable message transmission is impossible. Suppose that $`\pi `$ is a message transmission protocol from $`A`$ to $`B`$ and let $`W=W_0W_1`$ be a $`2k`$-node separation of $`A`$ and $`B`$ with $`W_0`$ and $`W_1`$ each having at most $`k`$ nodes. Let $`m_0`$ be the message that $`A`$ transmits. The adversary will attempt to maintain a simulation of the possible behavior of $`A`$ by executing $`\pi `$ for message $`m_1m_0`$. The strategy of the adversary is to flip a coin and then, depending on the outcome, decide which set of $`W_0`$ or $`W_1`$ to control. Let $`W_b`$ be the chosen set. In each execution step of the transmission protocol, the adversary causes each node in $`W_b`$ to follow the protocol $`\pi `$ as if the protocol were transmitting the message $`m_1`$. This simulation succeeds with nonzero probability. Since $`B`$ does not know whether $`b=0`$ or $`b=1`$, at the end of the protocol $`B`$ cannot decide whether $`A`$ has transmitted $`m_0`$ or $`m_1`$ if the adversary succeeds. Thus with nonzero probability, the reliability is not achieved. Q.E.D. $`\mathrm{}`$

Theorem 6.3 gives a sufficient and necessary condition for achieving reliable message transmission against a $`k`$-active adversary over hypergraphs. In the following example, we show that this condition is not sufficient for achieving privacy against a $`k`$-active adversary (indeed, even not for a $`k`$-passive adversary).

###### Example 1

Let $`H(V,E_h)`$ be the hypergraph in Figure 1 where $`V=\{A`$, $`B`$, $`v_1`$, $`v_2`$, $`v`$, $`u_1`$, $`u_2\}`$ and $`E_h=\{(A,\{v_1,v_2\})`$, $`(v_1,\{v,B\})`$, $`(v_2,\{v,B\})`$, $`(A,\{u_1,u_2\})`$, $`(u_1,\{v,B\})`$, $`(u_2,\{v,B\})\}`$. Then the nodes $`A`$ and $`B`$ are not 2-separable in $`H`$. Theorem 6.3 shows that reliable message transmission from $`A`$ to $`B`$ is possible against a 1-active adversary. However, the hypergraph $`H`$ is not weakly 2-connected (the removal of the node $`v`$ and the removal of the corresponding hyperedges will disconnect $`A`$ and $`B`$). Thus, the result by Franklin and Yung  shows that private message transmission from $`A`$ to $`B`$ is not possible against a 1-passive adversary.

###### Theorem 6.4

Let $`\delta >0`$ and $`A`$ and $`B`$ be two nodes in a hypergraph $`H(V,E)`$ satisfying the following conditions:

1. $`A`$ and $`B`$ are not $`2k`$-separable in $`H`$.
2. $`B`$ and $`A`$ are not $`2k`$-separable in $`H`$.
3. $`A`$ and $`B`$ are strongly $`k`$-connected in $`H`$.

Then there is a $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$ against a $`k`$-active adversary.

Proof. Assume that the conditions of the theorem is satisfied. For each $`k`$-node subset set $`S`$ of $`V\{A,B\}`$, let $`p_S`$ be a directed path from $`A`$ to $`B`$ which witnesses that $`A`$ and $`B`$ are strongly $`k`$-connected by removing the nodes in $`S`$ and corresponding hyperedges in $`H`$. Let $`𝒮=\{S:SV\{A,B\},|S|=k\}`$ and $`𝒫=\{p_S:S𝒮\}`$. Then $`A`$ transmits the message $`M^A`$ to $`B`$ using the following protocol.

* For each $`S𝒮`$, $`A`$ chooses a random pair $`(a_S,b_S)_R𝐅^2`$, and transmits this pair to $`B`$ via the path $`p_S`$.
* For each $`S𝒮`$, $`B`$ receives a pair $`(a_S^B,b_S^B)`$ from $`A`$ via the path $`p_S`$.
* For each $`S𝒮`$, $`B`$ chooses a random $`r_S_R𝐅`$ and computes $`s_S=\text{auth}(r_S;a_S^B,b_S^B)`$.
* $`B`$ reliably transmits $`s=r_S,s_S:S𝒮`$ to $`A`$.
* $`A`$ reliably receives the value $`s=r_S,s_S:S𝒮`$ from $`B`$.
* $`A`$ computes the key index set $`K_{\mathrm{index}}=\{i_S:s_S=\text{auth}(r_S;a_S^A,b_S^A)\}`$ and the shared secret $`K^A=_{i_SK_{\mathrm{index}}}a_S^A`$.
* $`A`$ reliably transmits $`K_{\mathrm{index}},M^A+K^A`$ to $`B`$, where $`M^A`$ is the secret message.
* $`B`$ reliably receives the value $`K_{\mathrm{index}},c`$ from $`A`$. $`B`$ computes the shared secret $`K^B=_{i_SK_{\mathrm{index}}}a_S^B`$, and decrypts the message $`M^B=cK^B`$.

It is possible that $`a_S^Aa_S^B`$ but $`\text{auth}(r_S;a_S^A,b_S^A)=\text{auth}(r_S;a_S^B,b_S^B)`$ for some $`S𝒮`$. However this probability is negligible. Thus the above protocol is reliable with high probability. Since $`A`$ and $`B`$ are strongly $`k`$-connected in $`H`$, there is a pair $`(a_S,b_S)`$ such that $`(a_S,b_S)`$ reliably reaches $`B`$ and the adversary cannot infer any information of $`a_S`$ from its view. Thus the above protocol is $`(0,\delta )`$-secure against a $`k`$-active adversary if one chooses sufficiently large F. Q.E.D. $`\mathrm{}`$

The results in Sections 3 and 4 show that the condition in Theorem 6.4 is not necessary.

## 7 Secure message transmission over neighbor networks

### 7.1 Definitions

A special case of the hypergraph is the neighbor networks. A neighbor network is a graph $`G(V,E)`$. In a neighbor network, a node $`AV`$ is called a neighbor of another node $`BV`$ if there is an edge $`(A,B)E`$. In a neighbor network, we assume that any message sent by a node $`A`$ will be received identically by all its neighbors, whether or not $`A`$ is faulty, and all parties outside of $`A`$’s neighbor learn nothing about the content of the message.

For a neighbor network $`G(V,E)`$ and two nodes $`A,B`$ in it, Franklin and Wright , and, Wang and Desmedt  showed that if there are $`n`$ multicast lines (that is, $`n`$ paths with disjoint neighborhoods) between $`A`$ and $`B`$ and there are at most $`k`$ malicious (Byzantine style) processors, then the condition $`n>k`$ is necessary and sufficient for achieving efficient probabilistically reliable and perfect private communication.

For each neighbor network $`G(V,E)`$, there is a hypergraph $`H_G(V,E_h)`$ which is equivalent to $`G(V,E)`$ in functionality. $`H_G(V,E_h)`$ is defined by letting $`E_h`$ be the set of hyperedges $`(A,A^{})`$ where $`AV`$ and $`A^{}`$ is the set of neighbors of $`A`$.

Let $`A`$ and $`B`$ be two nodes in a neighbor network $`G(V,E)`$. We have the following definitions:

1. $`A`$ and $`B`$ are $`k`$-connected in $`G(V,E)`$ if there are $`k`$ node disjoint paths between $`A`$ and $`B`$ in $`G(V,E)`$.
2. $`A`$ and $`B`$ are weakly $`k`$-hyper-connected in $`G(V,E)`$ if $`A`$ and $`B`$ are weakly $`k`$-connected in $`H_G(V,E_h)`$.
3. $`A`$ and $`B`$ are $`k`$-neighbor-connected in $`G(V,E)`$ if for any set $`V_1V\{A,B\}`$ with $`|V_1|<k`$, the removal of $`neighbor(V_1)`$ and all incident edges from $`G(V,E)`$ does not disconnect $`A`$ and $`B`$, where

$$neighbor(V_1)=V_1\{AV:\mathrm{thereexists}BV_1(B,A)\text{ such that }E\}\{A,B\}.$$
4. $`A`$ and $`B`$ are weakly $`(n,k)`$-connected if there are $`n`$ node disjoint paths $`p_1,\mathrm{},p_n`$ between $`A`$ and $`B`$ and, for any node set $`T(V\{A,B\})`$ with $`|T|k`$, there exists $`1in`$ such that all nodes on $`p_i`$ have no neighbor in $`T`$.

It is easy to check that the following relationships hold.

weak $`(n,k1)`$-connectivity $`(nk)`$ $``$ $`k`$-neighbor-connectivity $``$ weak $`k`$-hyper-connectivity $``$ $`k`$-connectivity

In the following examples, we show that these implications are strict.

###### Example 2

Let $`G(V,E)`$ be the graph in Figure 2 where $`V=\{A,B,C,D\}`$ and $`E=\{(A,C),(C,B),(A,D),(D,B),(C,D)\}`$. Then it is straightforward to check that $`G(V,E)`$ is 2-connected but not weakly 2-hyper-connected.

###### Example 3

Let $`G(V,E)`$ be the graph in Figure 3 where $`V=\{A,B,C,D,F\}`$ and $`E=\{(A,C)`$, $`(A,D)`$, $`(C,B)`$, $`(D,B)`$, $`(C,F)`$, $`(F,D)\}`$. Then it is straightforward to check that $`A`$ and $`B`$ are weakly $`2`$-hyper-connected but not $`2`$-neighbor-connected.

###### Example 4

Let $`G(V,E)`$ be the graph in Figure 4 where $`V=\{A`$, $`B`$, $`C`$, $`D`$, $`E`$, $`F`$, $`G`$, $`H\}`$ and $`E=\{(A,C)`$, $`(C,D)`$, $`(D,E)`$ $`(E,B)`$, $`(A,F)`$, $`(F,G)`$, $`(G,H)`$ $`(H,B)`$, $`(C,H)`$, $`(E,F)\}`$. Then it is straightforward to check that $`A`$ and $`B`$ are $`2`$-neighbor-connected but not weakly $`(2,1)`$-connected.

Example 2 shows that $`k`$-connectivity does not necessarily imply weak $`k`$-hyper-connectivity. Example 3 shows that weak $`k`$-hyper-connectivity does not necessarily imply $`k`$-neighbor-connectivity. Example 4 shows that $`k`$-neighbor connectivity does not necessarily imply weak $`(n,k1)`$-connectivity for some $`nk`$.

### 7.2 $`(0,\delta )`$-Secure message transmission over neighbor networks

Wang and Desmedt  have given a sufficient condition for achieving $`(0,\delta )`$-security message transmission against a $`k`$-active adversary over neighbor networks. In this section, we show that their condition is not necessary.

###### Theorem 7.1

(Wang and Desmedt ) If $`A`$ and $`B`$ are weakly $`(n,k)`$-connected for some $`k<n`$, then there is an efficient $`(0,\delta )`$-secure message transmission between $`A`$ and $`B`$.

The condition in Theorem 7.1 is not necessary. For example, the neighbor network $`G`$ in Example 3 is not $`2`$-neighbor-connected, thus not weakly $`(2,1)`$-connected. In the following we present a $`(0,\delta )`$-secure message transmission protocol against a 1-active adversary from $`A`$ to $`B`$ for the neighbor network of Example 3 .

Message transmission protocol for neighbor network $`G`$ in Example 3.

* $`A`$ chooses two random pairs $`(r_1^A,r_2^A)_R𝐅^2`$ and $`(r_3^A,r_4^A)_R𝐅^2`$. $`A`$ sends $`(r_1^A,r_2^A)`$ to $`C`$ and $`(r_3^A,r_4^A)`$ to $`D`$.
* $`B`$ chooses two random pairs $`(r_1^B,r_2^B)_R𝐅^2`$ and $`(r_3^B,r_4^B)_R𝐅^2`$. $`B`$ sends $`(r_1^B,r_2^B)`$ to $`C`$ and $`(r_3^B,r_4^B)`$ to $`D`$.
* $`C`$ chooses a random pair $`(a_1,b_1)_R𝐅^2`$. $`C`$ sends $`(a_1+r_1^A,b_1+r_2^A)`$ to $`A`$ and $`(a_1+r_1^B,b_1+r_2^B)`$ to $`B`$.
* $`D`$ chooses a random pair $`(a_2,b_2)_R𝐅^2`$. $`D`$ sends $`(a_2+r_3^A,b_2+r_4^A)`$ to $`A`$ and $`(a_2+r_3^B,b_2+r_4^B)`$ to $`B`$.
* From the messages received from $`C`$ and $`D`$, $`A`$ computes $`(a_1^A,b_1^A)`$ and $`(a_2^A,b_2^A)`$.
* From the messages received from $`C`$ and $`D`$, $`B`$ computes $`(a_1^B,b_1^B)`$ and $`(a_2^B,b_2^B)`$.
* $`B`$ chooses a random $`r_R𝐅`$, computes $`s_1=\text{auth}(r;a_1^B,b_1^B)`$ and $`s_2=\text{auth}(r;a_2^B,b_2^B)`$. Using the probabilistically reliable message transmission protocol of Franklin and Wright , $`B`$ transmits $`r,s_1,s_2`$ to $`A`$.
* Let $`r^A,s_1^A,s_2^A`$ be the message received by $`A`$ in the last step, $`A`$ computes the key index set $`K_{\mathrm{index}}=\{i:s_i^A=\text{auth}(r^A;a_i^A,b_i^A)\}`$. $`A`$ also computes the shared secret $`K^A=_{iK_{\mathrm{index}}}a_i^A`$.
* Using the probabilistically reliable message transmission protocol of Franklin and Wright , $`A`$ transmits $`K_{\mathrm{index}},M^A+K^A`$ to $`B`$, where $`M^A`$ is the secret message.
* Let $`K_{\mathrm{index}}^B,c^B`$ be the message that $`B`$ received in the last step. $`B`$ computes the shared secret $`K^B=_{iK_{\mathrm{index}}^B}a_i^B`$, and decrypts the message $`M^B=c^BK^B`$.

It is straightforward to check that the above protocol is an efficient $`(0,\delta )`$-secure message transmission protocol from $`A`$ to $`B`$ against a 1-active adversary.

Example 1 shows that for a general hypergraph, the existence of a reliable message transmission protocol does not imply the existence of a private message transmission protocol. We show that this is true for probabilistic reliability and perfect privacy in neighbor networks also.

###### Example 5

Let $`G(V,E)`$ be the neighbor network in Figure 5 where $`V=\{A,B,C,D,E,F,G\}`$ and $`E=\{(A,C),(C,D),(D,B),(A,E),(E,F),(F,B),(G,C),(G,D),(G,E),(G,F)\}`$. Then there is a probabilistic reliable message transmission protocol from $`A`$ to $`B`$ against a 1-active adversary in $`G`$. But there is no private message transmission from $`A`$ to $`B`$ against a 1-passive (or 1-active) adversary in $`G`$.

Proof. It is straightforward to check that $`G(V,E)`$ is not weakly 2-hyper-connected. Indeed, in the hypergraph $`H_G(V,E_h)`$ of $`G(V,E)`$, the removal of node $`G`$ and the removal of the corresponding hyperedges will disconnect $`A`$ and $`B`$ completely. Thus Franklin and Yung’s result in  shows that there is no private message transmission protocol against a 1-passive (or 1-active) adversary from $`A`$ to $`B`$. It is also straightforward to check that Franklin and Wright’s  reliable message transmission protocol against a 1-active adversary works for the two paths $`(A,C,D,B)`$ and $`(A,E,F,B)`$. Q.E.D. $`\mathrm{}`$

Though weak $`k`$-hyper-connectivity is a necessary condition for achieving probabilistically reliable and perfectly private message transmission against a $`(k1)`$-active adversary, we do not know whether this condition is sufficient. We conjecture that there is no probabilistically reliable and perfectly private message transmission protocol against a 1-active adversary for the weakly 2-hyper-connected neighbor network $`G(V,E)`$ in Figure 6, where $`V=\{A`$, $`B`$, $`C`$, $`D`$, $`E`$, $`F`$, $`G`$, $`H\}`$ and $`E=\{(A,C)`$, $`(C,D)`$, $`(D,E)`$, $`(E,B)`$, $`(A,F)`$, $`(F,G)`$, $`(G,H)`$, $`(H,B)`$, $`(D,G)\}`$. Note that in order to prove or refute our conjecture, it is sufficient to show whether there is a probabilistically reliable message transmission protocol against a 1-active adversary for the neighbor network. For this specific neighbor network, the trick in our previous protocol could be used to convert any probabilistically reliable message transmission protocol to a probabilistically reliable and perfectly private message transmission protocol against a 1-active adversary.