Binary Error Propagation (BEP)

• Binary Error Propagation (BEP) is the framework for analyzing and bounding binary errors in systems, crucial for cooperative communications, probabilistic inference, and binary neural network training.
• In wireless networks and probabilistic graphical models, BEP quantifies error floors and provides precise analytical bounds via closed-form expressions and dynamic-range contraction metrics.
• For binary neural network training, BEP introduces a binary chain rule and efficient bitwise operations that significantly boost performance while reducing computational complexity.

Binary Error Propagation (BEP) denotes the explicit analysis, propagation, or bounding of errors in binary-valued systems, with applications across cooperative wireless networks, probabilistic graphical models, and binary neural network training. The general principle describes how binary errors—either as physical bit errors due to channel noise, or as logical inaccuracies in binary message passing or gradient computations—propagate through layered or networked architectures, with detailed analytical tools for calculating the resultant degradations in reliability or performance.

1. Foundational Contexts and Definitions

In information theory and wireless communications, Binary Error Propagation arises classically in cooperative non-orthogonal multiple access (NOMA) and decode-forward (DF) relaying, where errors made by intermediate relays in decoding binary-valued symbols propagate end-to-end, creating error floors even under high signal-to-noise ratios. In probabilistic inference, BEP quantifies the gap between approximate and true marginals when belief propagation (BP) runs on binary Markov random fields (MRFs) with cycles. In binary neural network (BNN) training, BEP refers to the back-propagation of binary-valued error signals through multi-layer architectures without floating-point surrogates, addressing both gradient estimation and computational efficiency.

2. BEP in Cooperative Wireless Networks

In a decode-forward cooperative NOMA scheme over Nakagami-m fading channels, BEP rigorously quantifies bit error probability (BEP) for each user subject to binary error propagation from relay decisions (Kara et al., 2020). The canonical setup consists of a single-antenna source (S), decode-forward relay (R), and two users (D₁, D₂; "near" and "far"), communicating in two half-duplex phases:

• Phase 1 (S→R): S transmits superimposed BPSK-modulated symbols (x₁, x₂) using power allocation coefficients (α₁, α₂) with composite Nakagami-m channel fading.
• Relay Processing: R employs successive interference cancellation (SIC): decodes x₂ treating x₁ as interference, estimates and subtracts x₂ to decode x₁, potentially forwarding erroneous bits (Ĉx₁, Ĉx₂).
• Phase 2 (R→D): R re-encodes and forwards binary decisions to both users with its own power allocation (β₁, β₂).

The critical propagation mechanism is that relay decoding errors are "frozen" and propagated forward: if R decodes x_i incorrectly, the destination D_i cannot recover this error even with a high-quality R→D_i channel. The end-to-end BEP for user D_i is expressed as:

$$P^{(e2e)}_i = P^{(sr)}_i (1 − P^{(ri)}_i) + (1 − P^{(sr)}_i) P^{(ri)}_i,$$

where $P^{(sr)}_i$ and $P^{(ri)}_i$ are the average BEP on S→R and R→D_i, respectively. Closed-form expressions precisely account for power allocation, fading parameters (Nakagami-m shape m and mean Ω), and binary modulation, capturing diversity order and error floors due to BEP at the relay. This mechanism establishes how the “weakest” hop, either in terms of m or average SNR, dominates overall system reliability, and how error propagation precludes vanishingly low error probabilities unless both hops are concurrently reliable (Kara et al., 2020).

3. BEP in Binary Inference: Probabilistic Graphical Models

For binary pairwise Markov random fields (MRFs), Binary Error Propagation quantifies the fidelity of approximate marginals produced by loopy belief propagation (BP) relative to the exact marginals. The BEP metric is the dynamic range:

$$d(\mu_v/\hat \mu_v) = \max_{a,b \in \{0,1\}} \frac{\mu_v(a)/\mu_v(b)}{\hat \mu_v(a)/\hat \mu_v(b)} \geq 1,$$

with $\mu_v$ the true and $\hat \mu_v$ the BP marginal at node v. This provides tight multiplicative bounds on the approximation error.

For any binary MRF, a self-avoiding walk (SAW) tree rooted at v can be built; the exact marginal is realized as BP belief at its root under some leaf-forcing. A deterministic contraction bound is then propagated recursively on the SAW tree:

$$\delta_v = \prod_{u \in C(v)} \frac{\alpha_{uv}\delta_u + 1}{\alpha_{uv} + \delta_u},$$

where $\alpha_{uv}$ is the dynamic range of the pairwise potential on edge (u,v). By initializing all cycle-induced leaves with $\delta_s=0$, the computed $\delta_o$ at the root gives $d(\mu_v/\hat\mu_v)\leq \delta_o$, i.e., a worst-case error bound on BP (Ihler, 2012).

This approach contrasts with tree-reweighted bounds, and is particularly sharp for weakly coupled graphs or when BP exhibits strong mixing. The contraction under cycles ensures that, when dynamic ranges are moderate, BEP bounds are often significantly more informative than bounds derived purely from spanning trees.

4. Binary Error Propagation in Neural Network Training

In the context of Binary Neural Networks (BNNs), BEP defines the principle and specific algorithm for propagating binary error signals through multiple layers using only bitwise logic (Colombo et al., 3 Dec 2025). Traditional approaches such as quantization-aware training (QAT) require floating-point arithmetic for gradients, negating the full efficiency of binarized architectures. Local learning rules, while binary, lack global credit assignment and thus do not support deep learning.

The BEP algorithm introduces:

• Binary Chain Rule: Error signals are binary "desired activation" vectors, recursively updated as:

$\mathbf a_l^{*\mu} = \begin{cases} \pmb\rho^{c^\mu}, & l=L \ \sign\left(\mathbf W_{l+1}^{\top}(\mathbf g_{l+1}^\mu \odot \mathbf a_{l+1}^{*\mu})\right), & l<L \end{cases}$

where $\mathbf g_{l+1}^\mu$ is a binary gate (output is 1 if $|z_{l+1,i}^\mu| \leq \nu K_l$, 0 otherwise), acting as a discrete analog of the derivative-based gating in standard backpropagation.

• Weight Updates: Hebbian-style rank-1 updates with binary masking for sparsity and reinforcement for synaptic inertia. All updates are integer increments/decrements and can be fully implemented with bitwise logic.
• Efficiency: BEP requires only integer storage and computation (Int16 hidden weights, binary activations and error signals) and all forward and backward operations map to XNOR, Popcount, and basic logic. Compared to QAT+Adam, BEP reduces per-element computational gate count by approximately $10^3\times$ and parameter memory by $2\times$–$32\times$.

This algorithm implements for the first time a global, bit-precise backpropagation through fully binary multi-layer or recurrent architectures. Empirically, BEP achieves up to $+6.89\%$ gains on binary MLP classification and up to $+10.57\%$ on binary RNNs relative to binary QAT (Colombo et al., 3 Dec 2025).

5. Practical Computation and Theoretical Properties

The computation of BEP bounds or error propagation metrics depends on context:

• Communications: Closed-form BEP expressions over Nakagami-m are functions of integer parameters (shape m, average SNR, power allocations), and can be evaluated using summations and hypergeometric functions for each user and each link (Kara et al., 2020).
• Graphical Models: Computing BEP bounds requires growing the SAW tree (truncated at depth $K$) and recursive contraction per the dynamic-range update, with overall complexity proportional to the maximum degree and the chosen truncation depth. For large or dense graphs, this can be computationally expensive but is tractable for bounded-depth local neighborhoods (Ihler, 2012).
• Binary Neural Networks: All core computations are Boolean or integer, implemented in hardware-efficient bitwise primitives. The algorithm uses mask-based subsetting and mini-batch aggregation, achieving state-of-the-art performance in terms of both efficiency and accuracy on mid-scale datasets (Colombo et al., 3 Dec 2025).

6. Limitations, Insights, and Research Directions

Communications:

• Error floors: Due to binary error propagation at relays, the end-to-end BEP cannot be diminished below a certain threshold unless both source-relay and relay-destination links are robust. This effect is fundamental and persists even with optimal power allocation.
• Parameter impacts: The minimum Nakagami-m parameter across two hops sets the maximal achievable diversity order, with power allocation shifting end-to-end BEP trade-offs between users (Kara et al., 2020).

Probabilistic Inference:

• Tightness of bounds: BEP is tightest when loopy BP is rapidly mixing and potentials are not too strong. For high-coupling or critical regimes, BEP bounds become loose, coinciding with regimes where BP fixed points are not unique.
• Hybrid intervals: Intersection with spanning-tree bounds is possible for sharper confidence intervals and characterizes inference uncertainty more robustly (Ihler, 2012).

Binary Neural Networks:

• Scope: BEP is demonstrated for binary MLPs and RNNs. Application to CNNs and Transformers requires new development in binary convolution, masking, and multi-head operations. Use in regression or segmentation tasks demands changes to output encoding.
• Future directions: Adaptation to large-scale architectures, learnable binary gating thresholds, analytic convergence proofs, and federated/privacy-preserving BEP are noted as active areas for future work (Colombo et al., 3 Dec 2025).

7. Summary Table: BEP in Three Domains

Domain	Key Mechanism	Core Performance Impact
Cooperative relaying (NOMA)	Relay error freezing	Sets error-floor, dictates design constraints
Probabilistic inference (MRF/BP)	Dynamic-range contraction	Bounds BP marginals, confidence intervals
Binary neural network training	Discrete chain-rule backward	Enables end-to-end binary training, efficiency gains

BEP thus provides an essential analytic and algorithmic framework in domains where binary-valued errors or signals traverse multi-hop, multi-layer, or networked processes, with closed-form error quantification, algorithmic implementations, and implications for both theoretical limits and practical design (Kara et al., 2020, Ihler, 2012, Colombo et al., 3 Dec 2025).