A Message Passing Approach for Decision Fusion in Adversarial Multi-Sensor Networks
Andrea Abrardo Mauro Barni Kassem Kallas Benedetta Tondi













mymainaddress]Andrea Abrardo, Mauro Barni, Kassem Kallas and Benedetta Tondi






[mymainaddress]Department of Information Engineering and Mathematics, Via Roma 56, Siena, Italy




We consider a simple, yet widely studied, set-up in which a Fusion Center (FC) is asked to make a binary decision about a sequence of system states by relying on the possibly corrupted decisions provided by byzantine nodes, i.e. nodes which deliberately alter the result of the local decision to induce an error at the fusion center. When independent states are considered, the optimum fusion rule over a batch of observations has already been derived, however its complexity prevents its use in conjunction with large observation windows.

In this paper, we propose a near-optimal algorithm based on message passing that greatly reduces the computational burden of the optimum fusion rule. In addition, the proposed algorithm retains very good performance also in the case of dependent system states. By first focusing on the case of small observation windows, we use numerical simulations to show that the proposed scheme introduces a negligible increase of the decision error probability compared to the optimum fusion rule. We then analyse the performance of the new scheme when the FC make its decision by relying on long observation windows. We do so by considering both the case of independent and Markovian system states and show that the obtained performance are superior to those obtained with prior suboptimal schemes. As an additional result, we confirm the previous finding that, in some cases, it is preferable for the byzantine nodes to minimise the mutual information between the sequence system states and the reports submitted to the FC, rather than always flipping the local decision.




Adversarial signal processing, Decision fusion in adversarial setting, Decision fusion in the presence of Byzantines, Message passing algorithm, Factor graph.









§ INTRODUCTION


Decision fusion for distributed  detection has received an increasing attention for its importance in several applications, including  wireless
networks, cognitive radio, multimedia forensics and many others. One of the most common scenarios is the parallel distributed fusion model.  According to this model, the n nodes of a multi-sensor network gather information about a system and make a local decision about  the system status. Then the nodes send the local decisions to a Fusion Center (FC), which is in charge of making a final decision about the state of the system. <cit.>

In this paper, we focus on an adversarial version of the above problem,  in which a number of malicious nodes, often referred to as Byzantines <cit.>, aims at inducing a decision error at the FC <cit.>. This is a recurrent problem in many situations wherein the nodes may make a profit from a decision error. As an example, consider a cognitive radio system <cit.> in which secondary users cooperate in sensing the frequency spectrum to decide about its occupancy and the possibility to use the available spectrum to transmit their own data. While cooperation among secondary users allows to make a better decision, it is possible that one or more users deliberately alter their measurements to let the system think that the spectrum is busy, when in fact it is not, in order to gain an exclusive opportunity to use the spectrum. Online reputation systems offer another example <cit.>. Here a fusion center must make a final decision about the reputation of an item like a good or a service by relying on user's feedback. Even in this case, it is possible that malevolent users provide a fake feedback to alter the reputation of the item under inspection. Similar examples are found in many other applications, including wireless sensor networks <cit.>, <cit.>, distributed detection <cit.>, <cit.>, multimedia forensics <cit.> and adversarial signal processing <cit.>.

In this paper we focus on a binary version of the fusion problem, wherein the system can assume only two states. Specifically, the nodes observe the system over m time instants and make a local decision about the sequence of system states. Local decisions are not error-free and hence they may be wrong with a certain error probability. Honest nodes send their decision to the fusion center, while byzantine nodes try to induce a decision error and hence flip the local decision with probability P_mal before sending it to the FC. The fusion center knows that some of the nodes are Byzantines with a certain probability distribution, but it does not know their position.



 §.§ Prior Work


In a simplified version of the problem, the FC makes its decision on the status of the system at instant j by relying only on the corresponding reports, and ignoring the node reports relative to different instants. In this case, and in the absence of Byzantines, the Bayesian optimal fusion rule has been derived in <cit.>,<cit.> and it is known as Chair-Varshney rule. If local error probabilities are symmetric and equal
across the network, Chair-Varshney rule boils down to simple majority-based decision. In the presence of Byzantines, Chair-Varshney rule requires the knowledge of Byzantines' positions along with the flipping probability P_mal. Since this information is rarely available, the FC may resort to a suboptimal fusion strategy.


In <cit.>, by adopting a Neyman-Pearson setup and assuming that the byzantine nodes know the true state of the system, the asymptotic performance obtainable by the FC are analysed as a function of the percentage of Byzantines in the network. By formalising the attack problem as the minimisation of the Kullback-Leibler distance between the reports received by the FC under the two hypotheses, the blinding percentage, that is, the percentage of Byzantines irremediably compromising the possibility of making a correct decision, is determined.

In order to improve the estimation of the sequence of system states, the FC can gather a number of reports provided by the nodes before making a global decision (multiple observation fusion). In cooperative spectrum sensing, for instance, this corresponds to collectively decide about the white holes over a time window, or, more realistically, at different frequency slots. The advantage of deciding over a sequence of states rather than on each single state separately, is that in such a way it is possible for the FC to understand which are the byzantine nodes and discard the corresponding observations (such an operation is usually referred to as Byzantine isolation). Such a scenario has also been studied in <cit.>, showing that - at least asymptotically - the blinding percentage is always equal to 50%. In <cit.>, the analysis of <cit.> is extended to a situation in which the Byzantines do not know the true state of the system. Byzantine isolation is achieved by counting the mismatches between the reports received from each node and the global decision made by the FC. The performance of the proposed scheme are evaluated in a cognitive-radio scenario for finite values of n. In order to cope with the lack of knowledge about the strategy adopted by the attacker, the decision fusion problem is casted into a game-theoretic formulation, where each party makes the best choice without knowing the strategy adopted by the other party.

A slightly different approach is adopted in <cit.>. By assuming that the FC is able to derive the statistics of the reports submitted by honest nodes, Byzantine isolation is carried out whenever the reports received from a node deviate from the expected statistics. In this way, a correct decision can be made also when the percentage of Byzantines exceeds 50%. The limit of the approach proposed in <cit.>, is that it does not work when the reports sent by the Byzantines have the same statistics of those transmitted by the honest nodes. This is the case, for instance, in a perfectly symmetric setup with equiprobable system states, symmetric local error probabilities, and an attack strategy consisting of simple decision flipping.

A soft isolation scheme is proposed in <cit.>, where the reports from suspect byzantine nodes are given a lower importance rather being immediately discarded. Even in <cit.>, the lack of knowledge at the FC about the strategy adopted by the attacker (and viceversa) is coped with by adopting a game-theoretic formulation.

A rather different approach is adopted in <cit.>, where a tolerant scheme that mitigates the impact of Byzantines on the global decision is used rather that removing the reports submitted by suspect nodes from the fusion procedure.

When the value of P_mal and the probability that a node is Byzantine are known, the optimum fusion rule under multiple observation can be derived <cit.>. Since P_mal is usually not known to the FC, in <cit.> the value of P_mal used to define the optimum fusion rule and the value actually used by the Byzantines are strategically chosen in a game-theoretic context. Different priors about the distribution of Byzantines in the network are considered ranging from an extreme case in which the exact number of Byzantines in the network is known to a maximum entropy case. One of the main results in <cit.> is that the best option for the Byzantines is not to always flip the local decision (corresponding to P_mal = 1), since this would ease the isolation of malicious nodes. In fact, for certain combinations of the distribution of Byzantines within the network and the length of the observation window, it is better for the Byzantines to minimise the mutual information between the reports submitted to the FC and the system states.




 §.§ Contribution


The main problem of the optimum decision fusion scheme proposed in <cit.> is its computational complexity, which grows exponentially with the length of the observation window. Such a complexity prevents the adoption of the optimum decision fusion rule in many practical situations. Also the results regarding the optimum strategies of the Byzantines and the FC derived in <cit.> refer only to the case of small observation windows.

In the attempt to diminish the computational complexity while minimising the loss of performance with respect to the optimum fusion rule, we propose a new, nearly-optimum, fusion scheme based on message passing and factor graphs. Message passing algorithms, based on the so called Generalised Distributive Law (GLD, <cit.>,<cit.>), have been widely applied to solve a large range of optimisation problems, including decoding of Low Density Parity Check (LDPC) codes <cit.> and BCJR codes <cit.>, dynamic programming <cit.>, solution of probabilistic inference problems on Bayesian networks <cit.> (in this case message passing algorithms are known as belief propagation). Here we use message passing to introduce a near-optimal solution of the decision fusion problem with multiple observation whose complexity grows only linearly with the size of the observation window, thus marking a dramatic improvement with respect to the exponential complexity of the optimal scheme proposed in <cit.>.

Using numerical simulations and by first focusing on the case of small observation windows, for which the optimum solution can still be applied, we prove that the new scheme gives near-optimal performance at a much lower complexity than the optimum scheme. We then use numerical simulations to evaluate the performance of the proposed method for long observation windows. As a result, we show that, even in this case, the proposed solution maintains the performance improvement over the simple majority rule, the hard isolation scheme in <cit.> and the soft isolation scheme in <cit.>.

As opposed to previous works, we do not limit our analysis to the case of independent system states, but we extend it to a more realistic scenario where the sequence of states obey a Markovian distribution <cit.> as depicted in Figure <ref>. The Markovian model is rather common in the case of cognitive radio networks <cit.> where the primary user occupancy of the spectrum is often modelled  as a Hidden Markov Model (HMM).





The Markovian case is found to be more favourable for the FC with respect to the case of independent states, due the additional a-priori information available to the FC in this case.

Last but not the least, we confirm that the dual optimum behaviour of the Byzantines observed in <cit.> is also present in the case of large observation windows, even if in the Markovian case, the Byzantines may continue using the maximum attack power (P_mal = 1) for larger observation windows.

The rest of this paper is organised as follows. In Section <ref>, we introduce the notation used in the paper and give a precise formulation of the addressed problem. In Section <ref>, we describe the new message passing decision rule based on factor graph. In Section <ref>, we first discuss the complexity of the proposed solution compared to the optimal solution. Then, by considering both independent and Markovian system states, we compare the performance of the message passing algorithm to the majority rule, the hard isolation scheme <cit.>, the soft isolation scheme described in <cit.> and the optimal fusion rule. In addition, we discuss the impact that the length of the observation window has on the optimal behaviour of the Byzantines. We conclude the paper in Section <ref> with some final remarks.



§ NOTATION AND PROBLEM FORMULATION
 







The problem faced with in this paper, is depicted in Figure <ref>. We let 𝐬 = {s_1,s_2,…,s_m} with s_i ∈{0,1} indicate the sequence of system states over an observation window of length m. The nodes collect information about the system through the vectors x_1,  x_2 … x_n, with x_j indicating the observations available at node j. Based on such observations, a node j makes a local decision u_i,j about system state s_i. We assume that the local error probability, hereafter indicated as ε, does not depend on either i or j. The state of the nodes in the network is given by the vector 𝐡 = {h_1,h_2,…,h_n} with h_j = 1/0 indicating that node j is honest or Byzantine, respectively. Finally, the matrix 𝐑 = {r_i,j}, i = 1,…,m, j = 1,…,n contains all the reports received by the FC. Specifically, r_i,j is the report sent by node j relative to s_i. As stated before, for honest nodes we have u_i,j= r_i,j while, for Byzantines we have p (u_i,j r_i,j ) = P_mal. The Byzantines corrupt the local decisions independently of each other.


By assuming that the transmission between nodes and fusion center takes place over error-free channels, the report is equal to the local decision with probability 1 for honest nodes and with probability 1-P_mal for Byzantines. Hence, according to the local decision error model, we can derive the probabilities of the reports for honest nodes:


    p(r_i,j | s_i, h_j = 1) = (1-ε)δ(r_i,j-s_i)+ε (1-δ(r_i,j-s_i)),



where δ(a) is defined as:

    δ(a)=
        
          1,    if a=0 
    
          0,    otherwise.


On the other hand, by introducing η = ε(1-P_mal) + (1-ε)P_mal, i.e., the probability that the fusion center receives a wrong report from a byzantine node, we have:



    p(r_i,j | s_i, h_j = 0) = (1-η)δ(r_i,j-s_i)+η (1-δ(r_i,j-s_i))





As for the number of Byzantines, we consider a situation in which the states of the nodes are independent of each other and the state of each node is described by a Bernoulli random variable with parameter α, that is p(h_j=0)=α , ∀ j. In this way, the number of byzantine nodes in the network is a random variable following a binomial distribution, corresponding to the maximum entropy case <cit.> with  p(𝐡) = ∏_j p(h_j), where p(h_j) = α(1-h_j) + (1-α)h_j.

Regarding the sequence of states 𝐬, we assume a Markov model as shown in Figure <ref> , i.e., p(𝐬) = ∏_i p(s_i|s_i-1). The transition probabilities are given by p(s_i|s_i-1) = 1-ρ if s_i = s_i-1 and p(s_i|s_i-1) = ρ when s_i  s_i-1, whereas for i = 1 we have p(s_1|s_0) = p(s_1) = 0.5.

In this paper we look for the the bitwise Maximum A Posteriori Probability (MAP) estimation of the system states {s_i} which reads as follows:












    [                                                                            ŝ_i                                                                              =                                                     max_s_i ∈{0,1}  p(s_i | 𝐑)                                                                               ;                                                                                                                                                             =                                        max_s_i ∈{0,1}∑_{𝐬,𝐡}\ s_i p( 𝐬, 𝐡 | 𝐑)                                                     (law of total probability);                                                                                                                                                             =                             max_s_i ∈{0,1}∑_{𝐬,𝐡}\ s_i p(𝐑 | 𝐬, 𝐡) p (𝐬) p (𝐡)                                                                        (Bayes);                                                                                                                                                             = max_s_i ∈{0,1}∑_{𝐬,𝐡}\ s_i∏_i,jp(r_i,j | s_i, h_j )∏_i p(s_i|s_i-1) ∏_j p(h_j)                                                                                ]



where the notation ∑_\ denotes a summation over all the possible combinations of values that the variables contained in the expression within the summation may assume by keeping the parameter listed after the operator \ fixed. For a given 𝐡, the matrix of the observations 𝐑 at the FC follows a HMM <cit.>. 
The optimisation problem in (<ref>) has been solved in <cit.> for the case of independent system states. Even in such a simple case, however, the complexity of the optimum decision rule is exceedingly large, thus limiting the use of the optimum decision only in the case of small observation windows (typically m not larger than 10). In the next section we introduce a sub-optimum solution of (<ref>) based on message passing, which greatly reduces the computational complexity at the price of a negligible loss of accuracy.












§ A DECISION FUSION ALGORITHM BASED ON MESSAGE PASSING
 


 §.§ Introduction to Sum-product message passing
 
In this section we provide a brief introduction to the message passing (MP) algorithm for marginalization of sum-product problems. Let us start by considering N binary
variables 𝐳 = {z_1,z_2,…,z_N}, z_i ∈{0,1}. Then, consider the
function f(𝐳) with factorization:

    f(𝐳) = ∏_kf_k(𝒵_k)

where f_k, k = 1,,M are functions of a subset 𝒵_k of the
whole set of variables.
We are interested in computing the marginal of f with respect to a general variable z_i, defined as the sum of f over all possible values of 𝐳, i.e.:

    μ(z_i) = ∑_𝐳\ z_i∏_kf_k(𝒵_k)

where notation ∑_𝐳\ z_i denotes a
sum over all possible combinations of values of the variables in 𝐳 by keeping z_i fixed. Note that marginalization problem occurs when we want to compute any arbitrary probability from joint probabilities by summing out variables that we are not interested in. In this general setting, determining the marginals by
exhaustive search requires 2^N operations. However, in many situations it is possible to exploit the distributive law of multiplication to get a substantial reduction in complexity.

To elaborate, let associate with problem
(<ref>) a bipartite factor graph, in which for each variable we draw a variable node (circle) and for each function we draw a
factor node (square). A variable node is connected to a factor node k by an edge if and only if the corresponding variable belongs to 𝒵_k. This means that the set of vertices is partitioned into two groups (the set of nodes
corresponding to variables and the set of nodes corresponding to factors) and that
an edge always connects a variable node to a factor node. 

Let now assume that the factor graph is a
single tree, i.e., a connected graph where there is an unique path
to connect two nodes.
In this case, it is straightforward to derive an algorithm which
allows to solve the marginalization problem with reduced complexity. The algorithm is the
MP algorithm, which has been broadly used in the last years in
channel coding applications <cit.>, <cit.>.

To describe how the MP algorithm works, let us first define messages as 2-dimensional vectors, denoted
by 𝐦 = {m(0),m(1)}. Such messages are exchanged between variable nodes and function nodes and viceversa, according to the following rules.
Let us first consider variable-to-function messages (𝐦_vf), and take the portion of factor graph depicted in Fig. <ref> as an illustrative example. In this graph, the variable node z_i is connected to L factor
nodes, namely f_1,f_2,…,f_L. For the MP algorithm
to work properly, node z_i must deliver the messages
𝐦^(l)_vf, l = 1,…,L to all its adjacent nodes.
Without loss of generality, let us focus on message
𝐦^(1)_vf. Such a message can be evaluated and
delivered upon receiving messages 𝐦^(l)_fv, l =
2,…,L, i.e., upon receiving messages from all function nodes
except f_1. In particular, 𝐦^(1)_vf may be
straightforwardly evaluated by calculating the element-wise product of
the incoming messages, i.e.:

    m^(1)_vf(q) = ∏_j=2^Lm^(j)_fv(q)

for q=0,1.

Let us now consider factor-to-variable messages, and refer to the
factor graph of Fig. <ref> where P variable nodes are
connected to the factor node f_k, i.e., according to the previous
notation, 𝒵_k = {z_1,…,z_P}. In this case, the node f_k
must deliver the messages 𝐦^(l)_fv, l = 1,…,P to
all its adjacent nodes. Let us consider again
𝐦^(1)_fv: upon receiving the messages
𝐦^(l)_vf, l = 2,…,P, f_k may evaluate the
message 𝐦^(1)_fv as:

    m^(1)_fv(q) = ∑_z_2,…,z_P[ f_k(q,z_2,…,z_P)
    ∏_p=2^Pm^(p)_vf(z_p)]

for q=0,1.


Given the message passing rules at each node, it is now possible to
derive the MP algorithm which allows to compute the marginals in (<ref>).
The process starts at
the leaf nodes, i.e., those nodes which have only one connecting
edge. In particular, each variable leaf node passes an all-ones
message to its adjacent factor node, whilst each factor leaf
node, say f_k(z_i) passes the message m^(k)_fv(q) =
f_k(z_i = q) to its adjacent node z_i. After initialization at
leaf nodes, for every edge we can compute the outgoing message as
soon as all incoming messages from all other edges connected to the
same node are received (according to the message passing rules
(<ref>) and (<ref>)). When a message has been sent in both
directions along every edge the algorithm stops. This situation is
depicted in Fig. <ref>: upon receiving messages from all its
adjacent factor nodes, node z_i can evaluate the exact marginal as:


    μ(z_i) = ∏_k=1,…,Lm^(k)_fv(z_i).


With regard to complexity, factors to variables
message passing can be accomplished with 2^P
operations, P being the number of variables in f_k. On the other hand, variables to nodes message passing's complexity can be neglected, and, hence, the MP algorithm allows to noticeably reduce the complexity of the problem provided that the numerosity of 𝒵_k is much lower than N. With regard to the optimization, Equation (<ref>) evaluates the marginal for both z_i = 0 and z_i = 1, which represent the approximated computation of the sum-product for both hypotheses. Hence, the optimization is obtained by choosing the value of z_i which maximizes it.





 §.§ Nearly-optimal data fusion by means of message passing


The objective function of the optimal fusion rule expressed in (<ref>) can be seen as a marginalization of a sum product of functions of binary variables, and, as such, it falls within the MP framework described in the previous Section. More specifically, in our problem, the variables are the system states s_i and the status of the nodes h_j, while the functions are the probabilities of the reports shown in equations (<ref>) and (<ref>), the conditional probabilities p(s_i|s_i-1), and the a-priori probabilities p(h_j). The resulting bipartite graph is shown in Figure <ref>.



It is worth noting that the graph is a loopy graph, i.e., it contains cycles, and as such it is not a tree. However, although it was originally designed for acyclic graphical models, it was found that the MP algorithm can be used for general graphs, e.g., in channel decoding problems <cit.>. In general, when the marginalization problem is associated to a loopy graph, the implementation of MP requires to establish a scheduling policy to initiate the procedure, so that variable nodes may receive messages from all the connected factors, thus evaluating the marginals. In this case, a single run of the MP algorithm may not be sufficient to achieve a good approximation of the exact marginals, and progressive refinements must be obtained through successive iterations. However, in the presence of loopy graphs, there is no guarantee of either convergence or optimality of the final solution. In many cases, the performance of the message-passing algorithms is closely related to the structure of the graph, in general, and its cycles, in particular. Many previous works in the field of channel coding, e.g., see <cit.>, reached the conclusion that, for good performance, the factor graph should not contain short cycles. In our case, it is possible to see from Figure <ref> that the shortest cycles have order 6, i.e., a message before returning to the sender must cross at least six different nodes. We speculate that such a minimum cycles length is sufficient to provide good performance for the problem at hand. We will prove through simulations that such a conjecture is true.

To elaborate further, based on the graph of Figure <ref> and on the general MP rules reported in the previous Section, we are now capable of deriving the messages for the scenario at hand. In Figure <ref>, we display all the exchanged messages for the graph in Figure <ref> that are exchanged to estimate in parallel each of the states s_i, i ∈{0,1} in the vector 𝐬 = {s_1,s_2,…,s_m}.
Specifically, we have:


    [                                              τ_i^(l)(s_i)                                                         =                      φ_i^(l)(s_i) ∏_j = 1^nν_i,j^(u)(s_i)                                                 i = 1,…,m;                                              τ_i^(r)(s_i)                                                         =                      φ_i^(r)(s_i) ∏_j = 1^nν_i,j^(u)(s_i)                                                 i = 1,…,m;                                              φ_i^(l)(s_i)                                                         =            ∑_s_i+1  = 0,1 p(s_i+1 | s_i) τ_i+1^(l)(s_i+1)                                               i = 1,…,m-1;                                              φ_i^(r)(s_i)                                                         =            ∑_s_i-1 = 0,1 p(s_i | s_i-1)  τ_i-1^(r)(s_i-1)                                                 i = 2,…,m;                                              φ_1^(r)(s_1)                                                         =                                                    p(s_1)                                                          ;                                            ν_i,j^(u)(s_i)                                                         =             ∑_h_j= 0,1 p(r_i,j| s_i,h_j. ) λ_j,i^(u)(h_j)                                   i = 1,…,m,    j = 1,…,n;                                            ν_i,j^(d)(s_i)                                                         = φ_i^(r)(s_i)  φ_i^(l)(s_i)  ∏_k = 1  k  j^nν_i,k^(u)(s_i)                                 i = 1,…,m-1,    j = 1,…,n;                                            ν_m,j^(d)(s_m)                                                         =               φ_i^(r)(s_m)  ∏_k = 1  k  j^nν_m,k^(u)(s_m)                                                 j = 1,…,n;                                            λ_j,i^(d)(h_j)                                                         =            ∑_s_i= 0,1 p(r_i,j| s_i,h_j. )  ν_i,j^(d)(s_i)                                   i = 1,…,m,    j = 1,…,n;                                            λ_j,i^(u)(h_j)                                                         =                ω_j^(u)(h_j) ∏_q = 1  q  i^mλ_j,q^(d)(h_j)                                   i = 1,…,m,    j = 1,…,n;                                              ω_j^(d)(h_j)                                                         =                                 ∏_ i = 1 ^mλ_j,i^(d)(h_j)                                                 j = 1,…,n;                                              ω_j^(u)(h_j)                                                         =                                                    p(h_j)                                                 j = 1,…,n;                                                           ]






 
    < g r a p h i c s >
 

Factor graph for the problem at hand with the illustration of all the exchanged messages.





As for the scheduling policy, we initiate the MP procedure by sending the messages λ_j,i^(u)(h_j) = ω_j^(u)(h_j) to all p(r_i,j| s_i,h_j. ) factor nodes, and by sending the message p(s_1) to the variable node s_1. Hence, the MP proceeds according to the general message passing rules, until all variable nodes are able to compute the respective marginals. When this happens, the first iteration is concluded. Then, successive iterations are carried out by starting from leaf nodes and by taking into account the messages received at the previous iteration for the evaluation of new messages. Hence, the algorithm is stopped upon achieving convergence of messages, or after a maximum number of iterations.

The MP scheme described above can be simplified by observing that messages can be normalized without affecting the normalized marginals. Henceforward, let us consider as normalization factors the sum of the elements of the messages, i.e., if we consider for example τ_i^(l)(s_i), the normalization factor is τ_i^(l)(0)+τ_i^(l)(1). In this case, the normalized messages, say τ̅_i^(l)(s_i) can be conveniently represented as scalar terms in the interval (0,1), e.g., we can consider τ̅_i^(l)(0) only since τ̅_i^(l)(1) = 1 - τ̅_i^(l)(0). Accordingly, the normalized messages can be evaluated as:

    [                                                                                                                                                                                    τ̅_i^(l)                                                                                                                                                                                           =                                                                                             φ̅_i^(l)∏_j = 1^nν̅_i,j^(u)/φ̅_i^(l)∏_j = 1^nν̅_i,j^(u) + (1-φ̅_i^(l)) ∏_j = 1^n (1-ν̅_i,j^(u))                                                                                                                                                                                   i = 1,…,m;                                                                                                                                                                                    τ̅_i^(r)                                                                                                                                                                                           =                                                                                         φ̅_i^(r)∏_j = 1^nν̅_i,j^(u)/φ̅_i^(r)∏_j = 1^nν̅_i,j^(u)   + (1-φ̅_i^(r) ) ∏_j = 1^n (1-ν̅_i,j^(u) )                                                                                                                                                                                   i = 1,…,m;                                                                                                                                                                                    φ̅_i^(l)                                                                                                                                                                                           =                                                                                                                                                          ρτ̅_i+1^(l) + (1-ρ) (1-τ̅_i+1^(l))                                                                                                                                                                                 i = 1,…,m-1;                                                                                                                                                                                    φ̅_i^(r)                                                                                                                                                                                           =                                                                                                                                                          ρτ̅_i-1^(r) + (1-ρ) (1-τ̅_i-1^(r))                                                                                                                                                                                   i = 2,…,m;                                                                                                                                                                                    φ̅_1^(r)                                                                                                                                                                                           =                                                                                                                                                                                  p(s_1 = 0)                                                                                                                                                                                            ;                                                                                                                                                                                  ν̅_i,j^(u)                                                                                                                                                                                           =          p(r_i,j| 0,0. )λ̅_j,i^(u) + p(r_i,j| 0,1. ) (1-λ̅_j,i^(u))/p(r_i,j| 0,0. )λ̅_j,i^(u) + p(r_i,j| 0,1. ) (1-λ̅_j,i^(u)) + p(r_i,j| 1,0. )λ̅_j,i^(u) + p(r_i,j| 1,1. ) (1-λ̅_j,i^(u))                                                                                                                                                                     i = 1,…,m,    j = 1,…,n;                                                                                                                                                                                  ν̅_i,j^(d)                                                                                                                                                                                           =                                             φ̅_i^(r)φ̅_i^(l)∏_k = 1  k  j^nν̅_i,k^(u)/φ̅_i^(r)φ̅_i^(l)∏_k = 1  k  j^nν̅_i,k^(u) + (1-φ̅_i^(r)) (1-φ̅_i^(l))  ∏_k = 1  k  j^n (1-ν̅_i,k^(u))                                                                                                                                                                   i = 1,…,m-1,    j = 1,…,n;                                                                                                                                                                                  ν̅_m,j^(d)                                                                                                                                                                                           =                                                                         φ̅_m^(r)∏_k = 1  k  j^nν̅_m,k^(u)/φ̅_m^(r)∏_k = 1  k  j^nν̅_m,k^(u) + (1-φ̅_m^(r))   ∏_k = 1  k  j^n (1-ν̅_m,k^(u))                                                                                                                                                                                   j = 1,…,n;                                                                                                                                                                                  λ̅_j,i^(d)                                                                                                                                                                                           = p(r_i,j| 0,0. )  ν̅_i,j^(d) + p(r_i,j| 1,0. )  (1-ν̅_i,j^(d))/p(r_i,j| 0,0. )  ν̅_i,j^(d) + p(r_i,j| 1,0. )  (1-ν̅_i,j^(d)) + p(r_i,j| 0,1. )  ν̅_i,j^(d) + p(r_i,j| 1,1. )  (1-ν̅_i,j^(d))                                                                                                                                                                     i = 1,…,m,    j = 1,…,n;                                                                                                                                                                                  λ̅_j,i^(u)                                                                                                                                                                                           =                                                                          ω̅_j^(u)∏_q = 1  q  i^mλ̅_j,q^(d)/ω̅_j^(u)∏_q = 1  q  i^mλ̅_j,q^(d)  + (1-ω̅_j^(u)) ∏_q = 1  q  i^m (1-λ̅_j,q^(d))                                                                                                                                                                     i = 1,…,m,    j = 1,…,n;                                                                                                                                                                                    ω̅_j^(d)                                                                                                                                                                                           =                                                                                                                     ∏_ i = 1 ^mλ̅_j,i^(d)/∏_ i = 1 ^mλ̅_j,i^(d)+ ∏_ i = 1 ^m (1-λ̅_j,i^(d))                                                                                                                                                                                   j = 1,…,n;                                                                                                                                                                                    ω̅_j^(u)                                                                                                                                                                                           =                                                                                                                                                                                  p(h_j = 0)                                                                                                                                                                                   j = 1,…,n;                                                                                                                                                                                             ]





§ SIMULATION RESULTS AND DISCUSSIONS



In this section, we analyze the performance of the MP decision fusion algorithm. We first consider the computational complexity, then we pass to evaluate the performance in terms of error probability. In particular, we compare the performance of the MP-based scheme to those of the optimum fusion rule <cit.> (whenever possible), the soft isolation scheme presented in  <cit.>, the hard isolation scheme described in <cit.> and the simple majority rule. In our comparison, we consider both independent and Markovian system states, for both small and large observation window m.



 §.§ Complexity Discussion



In order to evaluate the complexity of the message passing algorithm and compare it to that of the optimum fusion scheme, we consider both the number of operations and the running time. By number of operations we mean the number of additions, substractions, multiplications and divisions performed by the algorithm to estimate the vector of system states 𝐬.

By looking at equation (<ref>), we see that running the message passing algorithm requires the following number of operations:



  * 3n+5 operations for each of τ̅_i^(l) and τ̅_i^(r).


  * 3 operations for each of φ̅_i^(l) and φ̅_i^(r).


  * 11 operations for ν̅_i,j^(u).

  * 3n+5 operations for ν̅_i,j^(d).

  * 3n+2 operations for ν̅_m,j^(d).

  * 11 operations for λ̅_j,i^(d).

  * 3m+2 operations for each of λ̅_j,i^(u) and ω̅_j^(d).



summing up to 12n+6m+49 operations for each iteration over the factor graph. On the other hand, in the case of independent node states, the optimal scheme in <cit.> requires 2^m(m+n) operations. Therefore, the MP algorithm is much less computationally expensive since it passes from an exponential to a linear complexity in m. An example of the difference in computational complexity between the optimum and the MP algorithms is depicted in Figure <ref>.















With regard to time complexity, Table <ref> reports the running time of the MP and the optimal schemes. For n=20, the optimal scheme running time is 17.547 times larger than that of the message passing algorithm. On the other hand, for the case of n=100, the optimal scheme needs around 4.258 times more than the message passing scheme. The tests have been conducted using Matlab 2014b running on a machine with 64-bit windows 7 OS with 16,0 GB of installed RAM and Intel Core i7-2600 CPU @ 3.40GHz.



 §.§ Performance Evaluation


In this section, we use numerical simulations to evaluate the performance of the message passing algorithm and compare them to the state of the art schemes. The results are divided into four parts. The first two parts consider, respectively, simulations performed with small and large observation windows m. Then, in the third part, we investigate the optimum behaviour of the Byzantines over a range of observation windows size. Finally, in the last part, we compare the case of independent and Markovian system states.

The simulations were carried out according to the following setup. We considered a network with n = 20 nodes, ε = 0.15, ρ = {0.95, 0.5} corresponding to Markovian and independent sequence of system states, respectively. The probability α that a node is Byzantine is in the range [0,0.45] corresponding to a number of Byzantines between 0 and 9. As to P_mal we set it to either  0.5 or 1[It is know from <cit.> that for the Byzantines the optimum choice of P_mal is either 0.5 or 1 depending on the considered setup.]. The number of message passing iterations is 5. For each setting, we estimated the error probability over 10^5 trials.



  §.§.§ Small m








To start with, we considered a small observation window, namely  m=10. With such a small value of m, in fact, it is possible to compare the performance of the message passing algorithm to that of the optimum decision fusion rule.
The results we obtained are reported in Figure <ref>. Upon inspection of the figure, the superior performance of the message passing algorithm over the Majority, Soft and Hard isolation schemes is confirmed. More interestingly, the message passing algorithm gives nearly optimal performance, with only a negligible performance loss with respect to the optimum scheme.

Figure <ref> confirms the results shown in Figure <ref> for Markovian system states (ρ = 0.95).




  §.§.§ Large m


Having shown the near optimality of the message passing scheme for small values of m; we now leverage on the small computational complexity of such a scheme to evaluate its performance for large values of m (m = 30). As shown in Figure <ref>, by increasing the observation window all the schemes give better performance, with the message passing algorithm always providing the best performance. Interestingly, in this case, when the attacker uses P_mal=1.0, the message passing algorithm permits to almost nullify the attack of the Byzantines for all the values of  α. Concerning the residual error probability, it is due to the fact that, even when there are no Byzantines in the network (α=0), there is still an error floor caused by the local errors at the nodes ε. For the case of independent states, such an error floor is around 10^-4. In Figure <ref> and <ref>, this error floor decreases to about 10^-5 because of the additional a-priori information available in the Markovian case.







  §.§.§ Optimal choice of P_mal for the Byzantines


One of the main results proven in <cit.>, is that setting P_mal = 1 is not necessarily the optimal choice for the Byzantines. In fact, when the FC manages to identify which are the malicious nodes, it can exploit the fact the malicious nodes always flip the result of the local decision to get useful information about the system state. In such cases, it is preferable for the Byzantines to use P_mal = 0.5 since in this way the reports send to the FC does not convey any information about the status of the system. However, in <cit.>, it was not possible to derive exactly the limits determining the two different behaviours for the Byzantines due to the impossibility of applying the optimum algorithm in conjunction with large observation windows. By exploiting the low complexity of the message passing scheme, we are now able to overcome the limits of the analysis carried out in <cit.>.

Specifically, we carried out an additional set of experiments by fixing α = 0.45 and varying the observation window in the interval [5,20]. The results we obtained confirm the general behaviour observed in <cit.>. For instance, in Figure <ref>, P_mal = 1.0 remains the Byzantines' optimal choice up to m=13, while for m > 13, it is preferable for them to use P_mal=0.5. Similar results are obtained for independent system states as shown in Figure  <ref>.










  §.§.§ Comparison between independent and Markovian System States



In this subsection, we provide a comparison between the cases of Markovian and independent system states.

By looking at Figure <ref> and <ref>, we see that the Byzantines  switch their strategy from P_mal=1 to P_mal = 0.5 for a smaller observation window (m=10) in the case of independent states (the switching value for the Markovian case is m = 13). We can explain this behaviour by observing that in the case of Markovian states, using P_mal = 0.5 results in a strong deviation from the Markovianity assumption of the reports sent to the FC thus making it easier the isolation of byzantine nodes. This is not the case with P_mal = 1, since, due to the symmetry of the adopted Markov model, such a value does not alter the expected statistics of the reports.

As a last result, in Figure <ref>, we compare the error probability for the case of independent and Markov sources. Since we are interested in comparing the achievable performance for the two cases, we consider only the performance obtained by the optimum and the message passing algorithms. Upon inspection of the figure, it turns out that the case of independent states is more favourable to the Byzantines than the Markov case. The reason is that the FC may exploit the additional a-priori information available in the Markov case to identify the Byzantines and hence make a better decision. Such effect disappears when α approaches 0.5, since in this case the Byzantines tend to dominate the network. In that case, the Byzantines' reports prevail the pool of reports at the FC and hence, the FC becomes nearly blind so that even the additional a-priori information about the Markov model does not offer a great help.





§ CONCLUSIONS
















In this paper, we proposed a near-optimal message passing algorithm based on factor graph for decision fusion in multi-sensor networks in the presence of Byzantines. The effectiveness of the proposed 

scheme is evaluated by means of extensive numerical simulations both for the case of independent and Markov sequence of states. 
Experiments showed that, when compared to the optimum fusion scheme, the proposed scheme permits to achieve near-optimal performance at a much lower computational cost: specifically, by adopting the new algorithm based on message passing we were able to reduce the complexity from exponential to linear. Such reduction of the complexity permits to deal with large observation windows, thus further improving the performance of the decision.
 
Results on large observation windows confirmed the dual behavior in the attacking strategy of the Byzantines,
looking for a trade-off between pushing the FC to make a wrong decision on one hand and reducing the mutual information between the reports and the system state on the other hand. 
In addition, the experiments showed that the case of independent states is more favorable to Byzantines than the Markovian case, due to the additional a-priori information available at the FC in the Markovian case.
 



As future work, we plan to focus on a scenario more favorable to the Byzantines, by giving them the possibility to access the observation vectors. In this way, they can focus their attack on the most profitable cases and avoid to flip the local decision when it is very likely that their action will have no effect on the FC decision.  Considering the case where the nodes can send to the FC more extensive reports (multi-bit case) <cit.> is another interesting extension.


















§ REFERENCES




