Zero-Knowledge Federated Learning for Privacy-Preserving 5G Authentication

1. Introduction

Fifth-generation (5G) wireless networks enable unprecedented connectivity for billions of devices through enhanced mobile broadband, ultra-reliable low-latency communications, and massive machine-type communications [1]. However, this massive scale introduces critical security challenges in authentication mechanisms that must ensure robust security while preserving user privacy [2].

Traditional 5G authentication relies on centralized credential verification where user equipment credentials are validated by core network functions [3]. While these mechanisms provide strong security through protocols like 5G-AKA, they suffer from privacy preservation limitations, single points of failure, and scalability constraints when handling billions of IoT devices [4].

Federated learning (FL) enables collaborative machine learning without centralizing sensitive data, allowing devices to jointly train authentication models while keeping data localized [5]. However, conventional FL faces gradient leakage vulnerabilities through gradient inversion and membership inference attacks [6]. State-of-the-art privacy-preserving FL systems employ homomorphic encryption (HE) [8], but HE introduces prohibitive computational overhead, communication costs, and energy consumption impractical for resource-constrained 5G devices [7]. HE-based FL incurs authentication latencies exceeding 300 ms, proof sizes above 500 KB, and energy consumption over 6 J per cycle [9].

Zero-knowledge proofs (ZKP) enable proving statement validity without revealing underlying information [10]. Recent advances in zk-SNARKs and zk-STARKs achieve practical proof generation with succinct proof sizes [11,12], making ZKP suitable for resource-constrained 5G environments.

This paper proposes Zero-Knowledge Federated Learning (ZK-FL), integrating zero-knowledge proofs with federated learning for privacy-preserving 5G authentication without homomorphic encryption burden. Each device generates succinct proof ${\mathrm{Proof}}_i=\mathrm{ZK}({\mathrm{Gradient}}_i,{\mathrm{Hash}}_i)$ demonstrating local model update correctness without revealing gradient values. The 5G core network verifies these proofs ensuring computational integrity while preserving complete privacy.

The main contributions are: (1) novel ZK-FL framework eliminating homomorphic encryption through zero-knowledge proofs for 5G authentication; (2) comprehensive system architecture integrating ZK-FL with 5G network functions; (3) rigorous mathematical formulation with formal security proofs; (4) extensive evaluation methodology including authentication latency, proof size, verification time, network overhead, and energy consumption; (5) comprehensive experiments demonstrating 77% latency reduction, 99.97% proof size reduction, and 95% energy savings while maintaining 99.3% authentication success rate.

2. Related Work

2.1. Privacy-Preserving Federated Learning

McMahan et al. []mcmahan2017communication introduced federated learning enabling collaborative training without centralizing data. However, gradient information leaks sensitive data through gradient inversion [6] and membership inference attacks [13]. Differential privacy (DP) approaches add calibrated noise to gradients [14,15], but face utility-privacy trade-offs degrading model accuracy. Secure multi-party computation enables joint computation [16] but faces scalability challenges in massive 5G deployments. Homomorphic encryption-based approaches [8,17] incur prohibitive computational costs with encryption operations consuming 150-500 ms per gradient and ciphertext expansion factors of 2000-4000× [18].

2.2. Zero-Knowledge Proof Systems

Traditional ZKP systems require multiple interaction rounds [19]. Modern constructions achieve non-interactivity through Fiat-Shamir transformation [20]. zk-SNARKs provide constant-size proofs through pairing-based cryptography [11]. Groth16 [21] achieves 128-256 byte proofs with verification under 10 ms but requires trusted setup. zk-STARKs eliminate trusted setups through information-theoretic security [12] but generate larger proofs (40-200 KB). Recent optimizations in Aurora [22] and PLONK [23] provide improved proof sizes.

2.3. 5G Authentication and Security

3GPP TS 33.501 defines 5G authentication including 5G-AKA and 5G-EAP-AKA [24]. Research identified privacy vulnerabilities including IMSI catching attacks [25], authentication relay attacks [26], and downgrade attacks [27]. Machine learning-based authentication enhancement applies deep learning for anomaly detection [28] and FL for collaborative intrusion detection [29], but these works do not address gradient privacy. Recent proposals explored anonymous authentication [4] and blockchain-based approaches [30] but face scalability limitations. No prior work integrates zero-knowledge proofs with federated learning for 5G authentication providing rigorous privacy guarantees without homomorphic encryption overhead.

3. System Model and Design Objectives

3.1. Network Model

We consider 5G network architecture following 3GPP Release 16 with service-based interfaces. The network comprises N user equipment devices $\{U{E}_1,\dots ,U{E}_N\}$ connecting through gNB base stations to core network functions including AMF, SMF, UPF, AUSF, and UDM. Participating devices are partitioned into M collaborative learners $\mathcal{C}=\{C_1,\dots ,C_M\}$ where $M\ll N$. Each client $C_i$ maintains local dataset ${\mathcal{D}}_i$ with heterogeneous non-IID authentication records. The global authentication model is parameterized by weights $w\in {\mathbb{R}}^d$. At training round t, the server broadcasts current global model $w^{\left(t\right)}$ to selected clients. Each client performs local training for E epochs, computing local gradient $g_i^{\left(t\right)}=\nabla \mathcal{L}(w^{\left(t\right)};{\mathcal{D}}_i)$.

3.2. Threat Model

We adopt an honest-but-curious adversary model where participants follow protocol specifications but attempt to infer private information. Threats include: Gradient inference attacks where adversaries reconstruct training samples from transmitted gradients [6]; Model inversion attacks where adversaries query models to extract training data distributions [31]; Membership inference attacks determining whether specific records were included in training datasets [13]; and Byzantine attacks where malicious clients submit manipulated gradients attempting model poisoning [32]. We assume the central aggregation server and communication channels are trusted within the secured 5G core network.

3.3. Design Objectives

ZK-FL aims to achieve: Privacy preservation where gradients remain completely hidden preventing gradient inversion, membership inference, and model inversion attacks; Computational efficiency with total latency below 100 ms satisfying URLLC constraints; Communication overhead not exceeding 1 KB per authentication; Energy efficiency below 500 mJ per authentication for battery-powered IoT devices; Scalability supporting 10,000-100,000 concurrent authentications; and Model accuracy maintaining success rates above 99%.

4. Proposed Zero-Knowledge Federated Learning Framework

4.1. Framework Overview

ZK-FL integrates zero-knowledge proof systems with federated learning enabling privacy-preserving gradient verification without homomorphic encryption. Each client generates succinct proof demonstrating correct local model computation without revealing gradient values. Let $\mathcal{R}$ denote the relation defining valid gradient computations:

$$\mathcal{R}=\{(x,w):x=(w^{\left(t\right)},{\mathcal{D}}_i,g_i^{\left(t\right)}),w={\mathrm{seed}}_i,g_i^{\left(t\right)}=\nabla \mathcal{L}(w^{\left(t\right)};{\mathcal{D}}_i)\}$$

(1)

The zero-knowledge proof system consists of: $\mathrm{Setup}\left(1^{\lambda }\right)\to \mathrm{pp}$ generating public parameters; $\mathrm{Prove}(\mathrm{pp},x,w)\to \pi$ outputting proof demonstrating $(x,w)\in \mathcal{R}$; and $\mathrm{Verify}(\mathrm{pp},x,\pi )\to \{0,1\}$ outputting 1 if proof is valid. The statement x includes commitment to gradient $h_i=\mathrm{Hash}\left(g_i^{\left(t\right)}\right)$. The proof demonstrates:

$${\pi }_i=\mathrm{ZK}(g_i^{\left(t\right)},h_i)\mathrm{such}\mathrm{that}{h}_i=\mathrm{Hash}\left(g_i^{\left(t\right)}\right)\wedge g_i^{\left(t\right)}=\nabla \mathcal{L}(w^{\left(t\right)};{\mathcal{D}}_i)$$

(2)

4.2. Detailed Protocol Specification

The ZK-FL protocol operates in training rounds $t=1,\dots ,T$ with the following phases:

Phase 1: Initialization – AUSF executes $\mathrm{Setup}\left(1^{\lambda }\right)$ generating public parameters distributed to participating clients. AUSF initializes global model $w^{\left(0\right)}$ and sets hyperparameters including learning rate $\eta$, batch size B, and local epochs E.

Phase 2: Client selection – At round t, AUSF selects subset ${\mathcal{S}}_t\subseteq \mathcal{C}$ of K clients with probability sampling proportional to data size: $P(C_i\in {\mathcal{S}}_t)\propto \left|{\mathcal{D}}_i\right|$. AUSF broadcasts current global model $w^{\left(t\right)}$ to selected clients.

Phase 3: Local training – Each selected client $C_i\in {\mathcal{S}}_t$ performs local training:

Algorithm 1 Local Training with Zero-Knowledge Proof Generation

Require:  Global model $w^{\left(t\right)}$, local dataset ${\mathcal{D}}_i$, learning rate $\eta$, epochs E Ensure:  Gradient commitment $h_i^{\left(t\right)}$, zero-knowledge proof ${\pi }_i^{\left(t\right)}$ 1: Initialize local model: $w_i^{(t,0)}\leftarrow w^{\left(t\right)}$ 2: for $e=1$ to E do 3:     for each minibatch $\mathcal{B}\subseteq {\mathcal{D}}_i$ of size B do 4:         Compute gradient: $g_{\mathcal{B}}\leftarrow \nabla \mathcal{L}(w_i^{(t,e)};\mathcal{B})$ 5:         Update model: $w_i^{(t,e)}\leftarrow w_i^{(t,e)}-\eta ·g_{\mathcal{B}}$ 6:     end for 7: end for 8: Compute local update: $g_i^{\left(t\right)}\leftarrow w_i^{(t,E)}-w^{\left(t\right)}$ 9: Generate commitment: $h_i^{\left(t\right)}\leftarrow \mathrm{SHA}-256\left(g_i^{\left(t\right)}\right)$ 10: Generate zero-knowledge proof: 11: ${\pi }_i^{\left(t\right)}\leftarrow \mathrm{Prove}\left(\mathrm{pp},(w^{\left(t\right)},h_i^{\left(t\right)}),(g_i^{\left(t\right)},{\mathrm{seed}}_i)\right)$ 12: return$h_i^{\left(t\right)},{\pi }_i^{\left(t\right)}$

4.3. Zero-Knowledge Proof Construction

We implement ZK proofs using Groth16 zk-SNARKs for constant-size proofs (128 bytes) and efficient verification (< 10 ms). The proof demonstrates satisfaction of arithmetic circuit $\mathcal{C}$ encoding gradient computation constraints. The circuit includes constraints for forward propagation, loss computation, backward propagation, and hash verification. Circuit size grows as $\left|\mathcal{C}\right|=O(d·E·|{\mathcal{D}}_i\left|\right)$. We employ optimizations including batch verification, fixed-point arithmetic approximation, and checkpointing.

Client $C_i$ constructs witness vector $w=(g_i,{\mathrm{seed}}_i,\left\{a^{(\ell )}\right\})$ containing private gradient, randomness, and intermediate activations. The prover computes:

$${\pi }_i=({\pi }_A,{\pi }_B,{\pi }_C)=\mathrm{Groth}16.\mathrm{Prove}(\mathrm{pk},x,w)$$

(3)

where $({\pi }_A,{\pi }_B,{\pi }_C)\in {\mathbb{G}}_1\times {\mathbb{G}}_2\times {\mathbb{G}}_1$ are group elements in bilinear pairing groups. AUSF verifies proof ${\pi }_i$ by checking:

$$e({\pi }_A,{\pi }_B)=e(\alpha ,\beta )·e(x·\gamma ,\delta )·e({\pi }_C,\delta )$$

(4)

requiring only 3 pairing operations and $O\left(\right|x\left|\right)$ scalar multiplications, achieving sub-10 ms verification.

5. Dataset Creation and Evaluation Metrics

5.1. Dataset Composition

We created comprehensive evaluation dataset simulating realistic 5G authentication scenarios with 10,000 authentication attempts across 1,000 unique devices over 30 days. Devices are classified into: Smartphones ($N_1=400$) with octa-core processors (2.8 GHz), 8 GB RAM; IoT sensors ($N_2=400$) with ARM Cortex-M4 (168 MHz), 256 KB RAM; Wearables ($N_3=150$) with dual-core processors (1.2 GHz), 1 GB RAM; and Vehicular units ($N_4=50$) with quad-core processors (2.0 GHz), 4 GB RAM. Authentication attempts are distributed across urban dense, suburban, rural, and indoor network conditions with varying signal quality. Each authentication record includes 87 features including identity, temporal, location, network, behavioral, and security features. The dataset exhibits realistic non-IID characteristics with authentication success rates ranging from 94% to 99.8%.

5.2. Evaluation Metrics

We evaluate using: Authentication latency $T_{\mathrm{auth}}=T_{\mathrm{local}}+T_{\mathrm{prove}}+T_{\mathrm{comm}}+T_{\mathrm{verify}}+T_{\mathrm{decision}}$ (target < 100 ms); Proof size $S_{\mathrm{proof}}$ (target < 1 KB); Verification time $T_{\mathrm{verify}}$ (target < 20 ms); Network overhead $O_{\mathrm{net}}={\displaystyle \frac{S_{\mathrm{proof}}+S_{\mathrm{commit}}}{S_{\mathrm{gradient}}}}\times 100\%$ (target < 5%); Energy consumption $E_{\mathrm{total}}=P_{\mathrm{CPU}}·T_{\mathrm{local}}+P_{\mathrm{crypto}}·T_{\mathrm{prove}}+P_{\mathrm{RF}}·T_{\mathrm{comm}}$ (target < 500 mJ); Authentication accuracy (target > 99%); False positive rate (target < 1%); False negative rate (target < 0.5%); and Scalability supporting concurrent authentications (target > 10,000).

6. Experimental Evaluation

6.1. Implementation and Setup

We implemented ZK-FL using Python 3.8 with PyTorch 1.12 and libsnark library. The authentication model is a 4-layer feedforward neural network with 87 input features, hidden layers of 128 and 64 neurons with ReLU activation, and binary output layer with sigmoid activation. Client devices are simulated on Amazon EC2 instances: c5.2xlarge for smartphones, t3.micro for IoT sensors, t3.small for wearables, and c5.xlarge for vehicular units. AUSF runs on c5.9xlarge instance (36 vCPUs, 72 GB RAM). We use ns-3 simulator version 3.35 with 5G-LENA module for realistic 5G network conditions. Training uses 100 clients per round, 10 local epochs, batch size 32, local learning rate 0.01, and global learning rate 0.1 for 50 communication rounds. Model parameters total $d=12,416$ floating-point values. We compare against: Baseline FL (standard federated averaging), HE-FL (Paillier encryption with 2048-bit keys), and DP-FL (Gaussian noise with $ϵ=1.0,\delta ={10}^{-5}$).

6.2. Authentication Latency Analysis

Table 1 presents latency breakdown across device types and protocols. ZK-FL achieves average authentication latency of 78.4 ms, representing 77.1% reduction compared to HE-FL (342.5 ms) and approaching baseline FL (52.3 ms) while providing strong privacy guarantees.

The latency advantage stems from eliminating expensive homomorphic operations. HE-FL requires the encryption of 12,416 gradient elements using modular exponentiation, which consumes 280-350 ms. ZK-FL proof generation uses efficient elliptic curve operations and hashing, requiring only 15-25 ms. Verification time is 6.2 ms for ZK-FL versus 198.4 ms for HE-FL.

6.3. Communication and Storage Overhead

Table 2 compares communication costs. The ZK-FL proof sizes average 0.128 KB (128 bytes for Groth16 proof plus 32 bytes for SHA-256 commitment), achieving a size reduction of 99.975% compared to the HE-FL ciphertexts (512 KB).

Gradient transmission size is 48.7 KB (12,416 float32 values × 4 bytes). ZK-FL adds only 160 bytes overhead (0.26%), compared to HE-FL which expands ciphertext size by 10.5×.

6.4. Energy Consumption

Table 3 presents energy consumption measurements. ZK-FL consumes average 284.5 mJ per authentication, achieving 95.6% reduction compared to HE-FL (6,525 mJ).

HE-FL’s high energy consumption (6.5 J) limits IoT devices to only 800-1,500 authentications per battery charge. ZK-FL extends this to 17,000-18,000 authentications, enabling practical long-term IoT deployment.

6.5. Scalability Evaluation

Table 4 evaluates performance with increasing concurrent requests. ZK-FL maintains sub-100 ms latency up to 5,000 concurrent authentications and achieves 99.3% success rate at 10,000 concurrent requests.

The scalability advantage stems from efficient parallel verification. AUSF can verify 10,000 proofs in 62 seconds using 36-core instance, whereas HE-FL requires 33 minutes for equivalent decryption operations.

6.6. Authentication Accuracy

Table 5 compares model accuracy across protocols. ZK-FL achieves 99.3% authentication accuracy, matching baseline FL (99.4%) and significantly outperforming DP-FL (96.1%).

DP-FL’s accuracy degradation (3.3% reduction) results from noise addition during gradient transmission. ZK-FL avoids this accuracy-privacy trade-off by preserving exact gradients during aggregation while protecting privacy through cryptographic guarantees.

7. Security Analysis

7.1. Privacy Guarantees

ZK-FL provides formal privacy guarantees through the zero-knowledge property of the underlying proof system. We establish the following security theorem:

Theorem 1. 

Privacy Preservation. The ZK-FL protocol satisfies computational zero-knowledge under the discrete logarithm assumption in bilinear groups. For any probabilistic polynomial-time adversary $\mathcal{A}$ with access to proofs $\left\{{\pi }_i\right\}$ and commitments $\left\{h_i\right\}$, the advantage in distinguishing real gradient distributions from uniform random distributions is negligible.

Proof of Theorem 1. 

We prove through a simulation argument. Construct a simulator $\mathcal{S}$ that, given only public parameters pp and statement $x=(w^{\left(t\right)},h_i)$, produces proof ${\pi }_i^{\prime }$ that is indistinguishable from the real proof ${\pi }_i$ generated by the honest prover with witness $(g_i,{\mathrm{seed}}_i)$. The simulator uses trapdoor information from the trusted setup to construct a valid-looking proof without knowledge of actual gradient. By the zero-knowledge property of Groth16, simulated proofs $\left\{{\pi }_i^{\prime }\right\}$ are computationally indistinguishable from real proofs $\left\{{\pi }_i\right\}$ under the discrete logarithm assumption. Therefore, adversary $\mathcal{A}$ cannot extract gradient information from observed proofs beyond what is revealed by public commitments (which are random 256-bit values under the collision resistance of SHA-256). This establishes computational zero-knowledge privacy. □

7.2. Soundness and Completeness

Theorem 2. 

The ZK-FL protocol satisfies computational soundness. For any probabilistic polynomial-time adversary $\mathcal{A}$ attempting to generate valid proof ${\pi }^{*}$ for false statement $x^{*}=(w^{\left(t\right)},h^{*})$ where $h^{*}\ne \mathrm{SHA}-256\left(g\right)$ for any correctly computed gradient g, the success probability is negligible..

Proof of Theorem 2. 

Soundness follows from the knowledge soundness of Groth16 and the collision resistance of SHA-256. Suppose adversary generates a valid proof ${\pi }^{*}$ for a false statement $x^{*}$. By knowledge soundness, an extractor extracts valid witness $(g^{*},{\mathrm{seed}}^{*})$ satisfying circuit constraints including hash verification: $h^{*}=\mathrm{SHA}-256\left(g^{*}\right)$. However, by assumption, $h^{*}$ does not correspond to any correctly computed gradient. This implies either: (1) $g^{*}$ was not computed through correct gradient descent, violating circuit constraints, or (2) a hash collision occurred, violating SHA-256 collision resistance. Case (1) contradicts successful verification. Case (2) occurs with negligible probability. Therefore, soundness holds. □

Theorem 3. 

The ZK-FL protocol satisfies perfect completeness. For any honest client $C_i$ that correctly computes the gradient $g_i=\nabla \mathcal{L}(w^{\left(t\right)};{\mathcal{D}}_i)$ and generates proof ${\pi }_i$ following protocol specification, the verification algorithm outputs 1 with probability 1.

Proof of Theorem 3. 

Completeness follows directly from Groth16 completeness. Honest prover constructs witness satisfying all circuit constraints by definition of correct gradient computation. The proof generation algorithm produces valid proof satisfying verification equation:

$$e({\pi }_A,{\pi }_B)=e(\alpha ,\beta )·e(x·\gamma ,\delta )·e({\pi }_C,\delta )$$

(5)

Since the witness satisfies constraints and proof is correctly formed, verification succeeds deterministically. □

7.3. Resistance to Gradient Inference Attacks

Traditional gradient inversion attacks [6] reconstruct training data by optimizing dummy inputs to match observed gradients. ZK-FL defeats such attacks by never exposing actual gradient values. Adversary observes only commitment $h_i=\mathrm{SHA}-256\left(g_i\right)$ and proof ${\pi }_i$, neither revealing gradient information under cryptographic assumptions. To quantify resistance, we simulated gradient inversion attacks where adversary attempts to recover training samples from observed ZK-FL communications. Success rate (reconstructed sample similarity $>90\%$ to original) was 0.02% for ZK-FL compared to 67.3% for baseline FL and 18.4% for DP-FL with $ϵ=1.0$. The negligible success rate confirms practical resistance to gradient inference.

7.4. Byzantine Robustness

While privacy is the primary focus, ZK-FL provides inherent robustness against certain Byzantine attacks. Malicious clients cannot submit arbitrary gradients with valid proofs, as soundness guarantees extracted witness corresponds to legitimate gradient computation. To enhance Byzantine resilience, we integrate ZK-FL with robust aggregation using coordinate-wise median aggregation and gradient clipping. Experimental results with 20% Byzantine clients show model accuracy degrades only 2.1% (from 99.3% to 97.2%), compared to 14.8% degradation without robust aggregation.

8. Discussion

8.1. Advantages over Homomorphic Encryption

ZK-FL provides key advantages over HE-based privacy-preserving FL: Computational efficiency with proof generation (15-25 ms) and verification (6.2 ms) significantly faster than HE encryption/decryption (280-350 ms and 198 ms); Communication efficiency with proof sizes (128 bytes) being 4000× smaller than HE ciphertexts (512 KB); Energy efficiency with 95% energy reduction enabling long-term battery-powered IoT deployments; No key management complexity eliminating complex HE key distribution; and Better scalability with parallel verification enabling linear scalability versus HE aggregation requiring sequential decryption.

8.2. Limitations and Challenges

Despite these advantages, ZK-FL faces limitations: Trusted setup requirement where Groth16 requires trusted setup ceremony, mitigated by multi-party computation ceremonies or transparent proof systems like zk-STARKs; Circuit complexity where expressing gradient computation as arithmetic circuits introduces overhead, alleviated by circuit optimization and selective verification; Fixed model architecture requiring regenerating proving/verification keys for model structure changes, addressed by universal proof systems like PLONK; and Proof generation latency adding 15-25 ms overhead compared to baseline FL, requiring hardware acceleration for ultra-low latency applications.

8.3. Integration with 5G Network Functions

Deploying ZK-FL in production 5G networks requires: AUSF integration enhancing Authentication Server Function with ZK proof verification capabilities; AMF coordination where Access and Mobility Management Function tracks client capabilities to optimize participation scheduling; UDM data storage where Unified Data Management stores authentication models and public parameters; and Network slicing allocating dedicated network slices for FL traffic ensuring quality of service guarantees.

9. Conclusion

This paper presented Zero-Knowledge Federated Learning (ZK-FL), a novel framework for privacy-preserving 5G authentication eliminating homomorphic encryption computational and communication overhead. By integrating zero-knowledge proofs with federated learning, ZK-FL enables devices to prove model correctness without revealing gradient information, achieving strong privacy guarantees through cryptographic zero-knowledge properties.

Comprehensive evaluation across 10,000 authentication attempts demonstrated ZK-FL achieves 77% authentication latency reduction (78.4 ms versus 342.5 ms), 99.97% proof size reduction (0.128 KB versus 512 KB), and 95% energy consumption reduction (284.5 mJ versus 6,525 mJ) compared to homomorphic encryption-based FL, while maintaining 99.3% authentication accuracy and providing formal privacy guarantees through zero-knowledge, soundness, and completeness properties.

Future research directions include: (1) developing hardware acceleration for zk-SNARK proof generation on IoT devices using cryptographic coprocessors, (2) exploring transparent proof systems like zk-STARKs to eliminate trusted setup requirements, (3) investigating recursive proof composition for hierarchical FL architectures, (4) extending ZK-FL to cross-silo scenarios with multiple network operators, and (5) integrating ZK-FL with blockchain-based decentralized authentication systems for enhanced resilience and auditability. The ZK-FL framework demonstrates that zero-knowledge proofs provide a practical alternative to homomorphic encryption for privacy-preserving federated learning in resource-constrained 5G environments, enabling privacy-preserving machine learning at the massive scale required for next-generation mobile networks.