A Verifiable Chained Federated Learning Framework with Distance-Based Grouped Mechanism

Abstract

In federated learning, multiple clients collaborate to train a global model without exchanging raw data, which addresses issues of data silos and the leakage of data privacy. However, existing federated learning schemes often suffer from high communication overhead and unreliable server-side aggregation. To address these limitations, this paper proposes a verifiable chained federated learning mechanism with Euclidean distance-based grouping, termed VDCG-FL. Grouping is used to improve communication efficiency, while verification ensures the accuracy of aggregated results. Unlike conventional approaches, VDCG-FL groups clients according to their Euclidean distance to the server, thereby reducing communication latency, avoiding long-distance transmissions, and enhancing the stability of model aggregation. Moreover, Lagrange interpolation is used for verification to ensure aggregation correctness while incurring significantly lower computational overhead than traditional cryptographic methods. Extensive experiments demonstrate that VDCG-FL improves aggregation stability under non-IID data distributions while simultaneously reducing communication overhead.

1. Introduction

The big data era has transformed machine learning, but traditional centralized approaches require participants to upload raw data to a central server, often compromising privacy. In fields such as finance and healthcare, privacy or legal constraints prevent data sharing, making it difficult to collect large, high-quality datasets for training. This deepens the challenges posed by data silos and privacy protection [1]. In 2016, McMahan et al. introduced federated learning (FL) [2], enabling distributed clients to collaboratively train a global model without sharing their local data. In each round, the server sends the global model to selected clients, who train locally and upload their updates for aggregation [3]. FL has become a key paradigm in edge computing, leveraging distributed resources while preserving data privacy. Despite avoiding raw data exchange, FL faces significant challenges, notably communication overhead [4] and privacy risks [5]. Large data transmissions, frequent rounds, and varying bandwidth make communication costs far exceed those of local training. Solutions like client subsampling [5], local updates [6], and model compression [7] aim to reduce this bottleneck. Privacy concerns persist on both the client and server sides, as local models or gradients can leak sensitive information [8], enabling attacks such as model inversion and membership inference [9,10,11,12]. Additionally, incorrect aggregation can compromise model integrity and increase privacy risks [13].

To reduce communication overhead and enhance FL security, chain-based FL schemes have been proposed [14]. In this scheme, all clients form a single chain, with model parameters transmitted and updated sequentially along it. Only the relay client uploads the aggregated result to the server, limiting server-client communication to a single interaction per round and significantly reducing server-side burden. The chain structure also enhances privacy, as the server cannot directly observe individual client updates. However, this serial process prevents parallelization and increases the wall-clock time per round. In large-scale scenarios with hundreds or thousands of clients, the chain structure introduces a major performance bottleneck. Long chains may also suffer from error accumulation and link instability, limiting applicability in complex or large-scale settings. To address these issues, group-based FL schemes have emerged. In 2022, Zhang et al. introduced G-VCFL (Grouped Verifiable Chained Privacy-Preserving Federated Learning) [15], grouping clients by neighbor lists so each group forms a short chain, with the last client communicating with the server. While this increases communication, groups can operate in parallel. In 2024, Xia et al. proposed SVCA (Secure and Verifiable Chained Aggregation for Privacy-Preserving Federated Learning) [16], which adds grouping atop a single chain, uses secret sharing to prevent client dropout, and introduces a commitment mechanism to verify client honesty. That same year, Cui et al. presented MChain-SFFL (Multi-Chain Aggregation Privacy Preserving for Server-Free FL) [17], which randomly selects multiple chain heads and establishes parallel chains for masked parameter transmission. Wei et al. introduced FedACT (An Adaptive Chained Training Approach for Federated Learning in Computing Power Networks) [18], an adaptive chained training method that uses computation-driven clustering—clients are clustered based on task processing latency to minimize server wait times.

However, these group-based chained FL schemes still have several limitations. For grouping, G-VCFL adopts the popular construction method for cellular communication environments, based on statistical factors such as the number of occurrences, to select reliable neighbors [19]. However, when user distribution is uneven or coverage is poor in blind areas, neighbor identification can be severely distorted, further affecting the grouping results. SVCA divides users from different regions into groups, but its strategy is vague and lacks theoretical grounding. MChain-SFFL, a decentralized chained framework, assumes that it has already established reliable neighbor lists among users and maintained stable communication in a peer-to-peer network. However, in practical deployments, peer-to-peer networks may experience dynamic node changes and network instability, which can affect the construction and maintenance of chains [20]. Regarding server-side security, G-VCFL ensures verifiable privacy-preserving learning via a lightweight pseudorandom generator, while SVCA uses a commitment mechanism for global model verification—though at a high computational cost. MChain-SFFL and FedACT, however, do not address server-side security concerns.

Although existing studies have addressed communication efficiency and security in federated learning from different perspectives, several limitations remain. Verifiable federated learning methods focus on ensuring the correctness of aggregation but introduce additional computational overhead. Group-based approaches improve efficiency by partitioning clients, but they typically lack mechanisms for verifying aggregation results. Chain-based federated learning reduces the number of communications with the server; however, its fully sequential structure leads to increased latency, especially in heterogeneous environments with straggler clients. Therefore, there is still no unified framework that can simultaneously improve communication efficiency, reduce latency, and provide verifiable aggregation. This paper proposes a verifiable chained and grouped federated learning framework, VDCG-FL. It groups clients based on their Euclidean distances to the server because geographically proximate clients often exhibit similar network connectivity characteristics, such as link quality, latency, and available bandwidth. Without introducing excessive communication overhead, VDCG-FL effectively reduces error accumulation in chained federated learning and improves link stability by parallel training across different groups. Meanwhile, a verifiable aggregation mechanism based on Lagrange interpolation on the server side enhances server-side security while reducing the additional computational cost introduced by the verification mechanism. It is worth noting that the grouping in this paper is used to improve communication efficiency, while the verification ensures the correctness of the aggregation results. Together, these two components form a federated learning framework that optimizes communication efficiency and guarantees the correctness of the aggregation results.

The main contributions of this work can be summarized as follows.

(1) Distance-based grouping: VDCG-FL groups clients by their Euclidean distance to the server. This reduces redundant communication and network overhead, while spatially grouping clients helps construct a more stable and efficient communication structure, resulting in more stable intra-group aggregation and avoiding long-distance transmissions. The scheme alleviates system heterogeneity, lowers latency, and improves training efficiency.

(2) Efficient server-side verification: VDCG-FL employs Lagrange interpolation for a server-side aggregation verification strategy, ensuring the correctness of global model parameters. Compared to homomorphic encryption-based schemes, this approach significantly reduces computational overhead, improves efficiency, and enhances the security and performance of aggregation.

(3) Extensive evaluation: We developed a VDCG-FL prototype and conducted experiments on MNIST and CIFAR-10 datasets, both independent and identically distributed datasets (IID) and non-IID, measuring accuracy, latency, and grouping performance. VDCG-FL achieves an accuracy of up to 99.36% on IID data and 98.87% on non-IID data. Furthermore, by dividing clients into 10 groups, the scheme reduces the average round latency from 44.33 s in a single-chain structure to 32.13 s, representing a reduction of approximately 27.5%.

The remaining part of this paper is organized as follows. Section 2 introduces the preliminary. Section 3 presents the system design objectives. Section 4 details the VDCG-FL scheme. Section 5 analyzes the system in terms of performance, privacy protection, and efficiency. Section 6 concludes the paper.

2. Preliminaries

In this section, we briefly introduce chain-based FL and the fundamental concepts of Lagrange interpolation.

2.1. Chain-Based Federated Learning

The Chain-FL organizes participating clients in a serial chain. Each client transmits its local model parameters along the chain, and only the relay client at the end of the chain uploads the final model to the server. Specifically, there is a set of restrictions

$$K=\{K_i\mid i=1,2,\dots ,N\},$$

where the set K contains N clients to form a single chain, and each client $K_i\in K$ owns its private local dataset $D_i$. In each round t, the first client $P_1$ trains its local model based on its local dataset $D_i$. The local model is updated using stochastic gradient descent (SGD) [21], and the resulting model parameters are masked with a token and passed along the chain to the next client $P_2$. This process continues until the relay client $P_N$ uploads the accumulated local model to the aggregation server, which then aggregates the global model for the current round.

2.2. Verifiable Federated Learning Based on Lagrange Interpolation

To enhance server-side security in FL, researchers proposed the first FL framework, VerifyNet, that jointly considers privacy preservation and verifiability [22]. This framework ensures the correctness of aggregated results through a verifiable aggregation proof mechanism based on NP-hard problems. However, it introduces significant communication and computational overhead. To address this issue, Guo et al. proposed VeriFL in 2020 [23], which also uses homomorphic hash functions to verify the correctness of the server’s aggregation, but it still suffers from lower efficiency and scalability. Wang et al. proposed the FVFL scheme [24], which ensures the security of customer data and resistance to collusion attacks using Paillier encryption and secret sharing. In 2023, Lin et al. proposed PPVerifier [25], a verification system based on the discrete logarithm. This system not only verifies the accuracy of aggregated results, but also identifies servers that did not participate in data aggregation. For large-scale client scenarios, Fu et al. proposed VFL in 2021 [26], which uses Lagrange interpolation to verify the server’s aggregation. Gao et al. proposed VCD-FL [27] to achieve effective validation of FL by grouping and compressing gradients to optimize Lagrangian interpolation. This scheme cannot increase verification overhead with the number of participating clients, thereby significantly improving its scalability. In the following, we will introduce the Lagrange interpolation method used in this paper. Lagrange interpolation is a classical polynomial interpolation method. Its core idea is to construct a polynomial function that exactly passes through a given set of discrete data points. Specifically, given $n+1$ interpolation points ${\left\{(x_i,y_i)\right\}}_{i=1}^n$, where $x_i$ for $i\in \{0,1,2,\dots ,n\}$ are all distinct, these $n+1$ points can be used to uniquely determine a polynomial of degree no greater than n:

$$F\left(x\right)=\sum _{i=1}^n{y}_i{l}_i\left(x\right)$$

(1)

where $l\left(x\right)$ denotes the interpolation basis function. It is also an n-degree polynomial defined as follows:

$$l_i\left(x\right)=\prod _{j=0,j\ne i}^n{\displaystyle \frac{(x-x_j)}{(x_i-x_j)}},(i=0,1,\dots ,n.)$$

(2)

Obviously, $F\left(x_i\right)=y_i$, given a $x_i$. Therefore, the curve constructed by the interpolation function strictly passes through all given points. Fu et al. [26] applied the Lagrange interpolation method to federated learning for the first time to validate the correctness of server aggregation results.

3. System Overview

This section briefly introduces some symbols used in VDCG-FL, summarized in

Table 1. Symbols and description.

Symbol	Description
$P_i$	client index
N	number of total clients
$D_i$	local dataset of client i
m	number of groups
$G_j$	group j
$c_{j,s}$	s-th client in group j
$R_j$	j-th relay client
S	group size
$a_i$	auxiliary sequence
t	training round
${\delta }^t$	random mask at round t
${\tilde{W}}_{G_j}^t$	masked group model of $G_j$ at round t
$W_{G_j}^t$	group model of $G_j$ at round t
$w_i^t$	local model of client i at round t
$W_t$	global model at round t
${\theta }_i^t$	masked local model of client i
$\eta$	learning rate
$v_j^t$	the j-th slice of global model
$u_j^t$	the j-th reference slice held locally by each client
$y_1$	the value of F(x) at a new verification point
$y_2$	interpolation using local reference slices

, the threat model, and the overall framework.

3.1. Threat Model

To meet practical application requirements, the VDCG-FL framework aims to design a federated learning scheme that protects users’ uploaded local models and prevents server-side insecure aggregation based on the following assumptions.

First, the aggregation server may be malicious. It may intentionally return incorrect aggregation results or behave lazily by not performing correct computations, resulting in a global model that deviates from the correct result. This assumption holds practical significance. In real-world implementation scenarios, single points of failure exist. Attackers may compromise the aggregation server to fabricate inaccurate aggregated results or violate users’ privacy.

Second, users participating in FL are assumed to be honest but curious. They correctly train local models and may also attempt to infer private information from other users. This assumption also reflects real-world applications, as users are often curious about others’ information.

3.2. Outline of VDCG-FL

This subsection provides a concise overview of VDCG-FL, with its workflow illustrated in Figure 1. The VDCG-FL framework involves three entities: a trusted authority (TA), clients, and an aggregation server (AS). The roles of these entities are described below.

• The trusted authority (TA): TA is a reliable entity responsible for system initialization. It generates auxiliary sequences for interpolation points and random mask vectors to conceal local models. The TA is assumed trustworthy by default, does not participate in federated training, and never discloses private information—its sole role is generating system parameters.
• Clients: In the VDCG-FL framework, clients are grouped according to their Euclidean distance from the server, and model updates are passed sequentially within each group. The relay client handles communication with the server, uploads the group’s aggregated model parameters, and verifies the correctness of the global model parameters from the aggregation server. Grouping clients in this way reduces the number of required interpolation points and ensures only relay clients communicate with the server, lowering interpolation costs and enabling efficient verification.
• Aggregation server (AS): AS acts as the central hub, collecting models from each group’s relay client and updating the global model. It aggregates these results and broadcasts the updated model to all groups or clients. The AS does not access clients’ raw data or intra-group transmissions; its role is limited to parameter collection and distribution. Because the AS is potentially untrusted in VDCG-FL, clients must verify its aggregation results.

3.3. Workflow of VDCG-FL

Here is a brief overview of the VDCG-FL workflow.

3.3.1. Initialization Phase

In this phase, the system initializes global parameters. The TA generates a constant sequence to construct the Lagrange interpolation function and mask values to protect local models, and broadcasts these parameters to the clients.

3.3.2. Local Model Training Phase

In VDCG-FL, N clients are partitioned into m groups according to their Euclidean distances to the server. Inside every group, clients are arranged in a chain and train local models on their private datasets. According to the chain sequence, clients sequentially transmit their masked models within the group until the final client receives and aggregates them locally.

3.3.3. Secure Model Aggregation Phase

After receiving the model parameter from relay clients, the server applied FedAvg to compute the global model and broadcast it to each group’s relay client for verification. Each relay client constructs a specific verification function to check the correctness of the global model for its group. Once verification fails, the client refuses the model and halts the current training round. If verification is successful, the client accepts the model.

This section details a description of three phases of VDCG-FL: the initialization phase, the local training phase, and the secure model aggregation phase.

3.4. Initialization Phase

We assume that the system includes N clients, denoted as $P_i,i=1,2,\dots ,N$ $(N\ge 2)$.

1.

The TA assigns a random coordinate vector $p_i=(x_i,y_i)$ to each client in the system. Next, the system computes the Euclidean distance from each client to the server, then sorts and organizes the clients by these distances. Each group forms a chained communication. Assume that the server is located at the origin $(0,0)$, and client i has the coordinate $(x_i,y_i)$. The Euclidean distance is calculated accordingly:

$$d_i=\sqrt{{(x_i-0)}^2+{(y_i-0)}^2}.$$

(3)

After sorting the clients in ascending order of distance $d_i$, they are divided into m groups: $G_1=\{c_{1,1},c_{1,2},\dots ,c_{1,S}\}$, $G_2=\{c_{2,1},c_{2,2},\dots ,c_{2,S}\}$, …, $G_j=\{c_{j,1},c_{j,2},\dots ,$$c_{j,S}\}$. Here $c_{i,j}$ denotes the j-th client in the i-th group. The set of all groups is $G=\{G_1,G_2,\dots ,G_m\}$, and each group contains S clients that communicate in a chain. Distance-based grouping has two advantages. First, it reduces intra-group communication latency by organizing geographically close clients together, which helps lower communication costs and avoid long-distance transmissions. Second, it improves overall training efficiency by enabling parallel execution across groups. Compared with a fully sequential chain, the grouping strategy reduces waiting time caused by slow clients and improves training efficiency.

2.

After system initialization, the TA randomly selects m distinct scalar points and assigns each group a unique interpolation auxiliary sequence $a_i$, denoted as $a_i=\{a_1,a_2,\dots ,a_m\}$ and a random number $a^{*}\notin \{a_1,a_2,\dots ,a_m\}$. Then the TA sends these sequences to the relay client of each group.

3.

During the initialization phase, the TA sends a random mask ${\delta }^t$ to each group to protect the privacy of intra-group aggregation results during upload. Each random mask matches the dimensionality of the global model parameters for subsequent secure aggregation. The mask is sequentially transmitted within the group following the chain until it reaches the relay client. Algorithm 1 provides a more detailed step-by-step procedure.

Algorithm 1 Initialization of VDCG-FL

Input: The number of clients N; auxiliary sequence length m Output: Initial global model $W_0$; client groups $G_j$; auxiliary sequence $a_i$ 1: Compute Euclidean distance $d_i$ for each client: 2:    $d_i=\sqrt{{(x_i-0)}^2+{(y_i-0)}^2}$ 3: Sort clients according to $d_i$ 4: Divide clients into m groups $G_j$ based on distance order 5: Initialize the global model $W_0$ 6: Generate auxiliary sequence $a_i$ Return $W_0$, $G_j$, $a_i$

3.5. Local Training Phase

At this stage, VDCG-FL initiates local training for clients in each group. Model parameters are passed and updated sequentially along the chain, with the relay client carrying out intra-group aggregation and communicating with the aggregation server. Algorithm 2 provides a more detailed procedure.

Algorithm 2 VDCG-FL Training and Secure Aggregation

Input: Initial model $W^0$; training rounds T; learning rate $\eta$; groups $G_j$; auxiliary sequence $a_i$; a random number $a^{*}$; random mask ${\delta }^t$; loss function $L(W;D)$; verification threshold $ϵ$ Output: Final global model $W^t$   1:   //Local Training phase:   2:   for  $t=1,2,\dots ,T$ do   3:       Aggregation server broadcasts $W^t$   4:       TA sends random mask ${\delta }^t$ to first and relay clients   5:       for each group $G_j$ do   6:           for each client $P_i\in G_j$ do   7:               Update local model:   8:                   $w_i^t\leftarrow W^{t-1}-\eta \nabla L(W^{t-1},D_i)$   9:               Compute masked update: 10:                   ${\theta }_i^t=w_i^t+{\theta }_{i-1}^t$ 11:           end for 12:           Relay client $R_j$ removes mask: 13:               $W_{G_j}^t={\tilde{W}}_{G_j}^t-{\delta }^t$ 14:           Upload $W_{G_j}^t$ to server 15:       end for 16:       //Secure Aggregation phase: 17:       Compute global aggregation: 18:           $W^t={\displaystyle \frac{1}{m}}{\sum }_{j=1}^m{W}_{G_j}^t$ 19:       Split $W^t$ into m shares and the j-th share can be defined as: 20:           $v_j^t=W^t\left[{\displaystyle \frac{\left(j-1\right)d}{m}}:{\displaystyle \frac{jd}{m}}\right], j=1,2,\dots ,m$ 21:       Each $R_j$ receives $v_j^t$ and holds $W_{G_j}^t$ 22:       $R_j$ splits $W_{G_j}^t$ into m shares and sends the s-th segment to $R_s$ 23:       The s-th share can be defined as: $W_{G_j}^t\left[{\displaystyle \frac{\left(s-1\right)d}{m}}:{\displaystyle \frac{sd}{m}}\right],\forall s\ne j$ 24:       Each $R_j$ holds $W_{G_1}^t[j-thsegment],W_{G_2}^t[j-thsegment],\dots ,W_{G_m}^t[j-thsegment]$ 25:       Each $R_j$ locally calculate reference slices $u_j^t$ as: 26:           $u_j^t={\displaystyle \frac{1}{m}}{W}_{G_j}^t\left[{\displaystyle \frac{\left(s-1\right)d}{m}}:{\displaystyle \frac{sd}{m}}\right],\forall s\ne j$ 27:       Each $R_j$ constructs two interpolation polynomials: 28:           $F\left(x\right)={\sum }_{j=1}^m{v}_j^t{\prod }_{k=1,k\ne j}^m{\displaystyle \frac{x-a_k}{a_j-a_k}}$ 29:           $G\left(x\right)={\sum }_{j=1}^m{u}_j^t{\prod }_{k=1,k\ne j}^m{\displaystyle \frac{x-a_k}{a_j-a_k}}$ 30:       Calculate the values at the verification point $a*$:$y_1=F\left(a^{*}\right),y_2=G\left(a^{*}\right)$ 31:       if $y_1=y_2$ then 32:           Accept $W^t$ 33:       else 34:           Reject the global model and rollback to the $W^{t-1}$ 35:       end if 36:   end for Return $W^t$

1.

The aggregation server broadcasts the current global model $W_t$ to all clients when the training starts.

2.

Each client $P_i$ in the group then starts training its local model parameters $w_i^t$ with its private dataset $D_i$:

$$w_i^t=W^{t-1}-\eta \nabla \mathcal{L}(W^{t-1},D_i),$$

(4)

where $w_i^t$ represents the local model of the client i in round t, $\eta$ is the learning rate; $W_G^t$ is the global model in round t; $\mathcal{L}$ is the loss function; and $\nabla \mathcal{L}$ denotes the gradient of the loss function with respect to the model parameters.

3.

After completing local training in each round, clients within a group perform chain-based communication for intra-group aggregation. Taking the first group $G_1$ as an example. Once the first client $P_1$ finishes local model training, it computes the masked parameter ${\theta }_1^t$ as follows:

$${\theta }_1^t=w_1^t+{\delta }^t.$$

(5)

which is then forwarded along the chain. When the i-th client receives the masked intermediate value ${\theta }_{i-1}^t$, it updates the accumulated result as:

$${\theta }_i^t=w_i^t+{\theta }_{i-1}^t=\sum _{j=1}^i{w}_j^t+{\delta }^t.$$

(6)

and passes it to the next client. This process continues until the relay client $P_S$ in the group, and the accumulated value reaching the last client is denoted as ${\tilde{W}}_{G_j}^t$:

$${\tilde{W}}_{G_j}^t={\theta }_S^t=w_S^t+{\theta }_{S-1}^t=\sum _{j=1}^S{w}_j^t+{\delta }^t,$$

(7)

The relay client then removes the mask by subtracting ${\delta }^t$ to obtain the true intra-group aggregation result. It then uploads this result to the aggregation server for global aggregation.

$$W_{G_1}^t={\tilde{W}}_{G_j}^t-{\delta }^t.$$

(8)

3.6. Secure Model Aggregation Phase

Once the server receives the locally aggregated models from all groups, it applies FedAvg to compute the global model. After aggregating all local models, the server splits the result into m shares, denoted as $v_j^t,j=1,2,\dots ,m$, and assigns them to the relay client $R_j$.

$$v_j^t=W^t\left[{\displaystyle \frac{\left(j-1\right)d}{m}}:{\displaystyle \frac{jd}{m}}\right],j=1,2,\dots ,m$$

(9)

At this point, $R_j$ receives only the segment with its own number; it cannot see other segments or the complete $W^{t+1}$.

At this step, $R_j$ slices its $W_{G_j}^t$ according to the receiver number and then sends them to the remaining relay Client. For example, $R_j$ sends $W_{G_j}^t\left[{\displaystyle \frac{\left(s-1\right)d}{m}}:{\displaystyle \frac{sd}{m}}\right],\forall s\ne j$ to $R_s$. After finishing the exchange, $R_j$ holds: $W_{G_1}^t[j-thsegment],\dots ,W_{G_m}^t[j-thsegment]$. And $R_j$ is used to calculate the reference slice $u_j^t$ with the segments:

$$u_j^t={\displaystyle \frac{1}{m}}{W}_{G_j}^t\left[{\displaystyle \frac{\left(s-1\right)d}{m}}:{\displaystyle \frac{sd}{m}}\right],\forall s\ne j$$

(10)

which means if the server aggregates honestly, then the j-th segment of $W_t$ should be equal to the value of $u_j^t$.

Therefore, assuming the server is honest, the following must be true:

$$u_j^t=v_j^t$$

(11)

In the next step, each relay client constructs the interpolation polynomials F(x) and G(x):

$$F\left(x\right)=\sum _{j=1}^m{v}_j^t\prod _{k=1,k\ne j}^m{\displaystyle \frac{x-a_k}{a_j-a_k}};G\left(x\right)=\sum _{j=1}^m{u}_j^t\prod _{k=1,k\ne j}^m{\displaystyle \frac{x-a_k}{a_j-a_k}}$$

(12)

Then, substitute the verification point $a^{*}$ into these two equations, calculate $y_1$ and $y_2$, and check if they are equal. If $y_1=y_2$, then the verification passes; if $y_1\ne y_2$, verification fails and rollbacks to the $W^{t-1}$.

In summary, the proposed verification mechanism using Lagrange interpolation ensures the integrity of the global aggregation result. Each relay client independently reconstructs a local reference value from locally available information and compares it against the server-distributed result through polynomial evaluation at a randomly chosen verification point generated by the Trusted Authority. Formally, the mechanism is shown to satisfy both completeness and correctness of the aggregation result.

4. Theoretical Analysis

4.1. Analysis of Verification Correctness

Theorem 1.

In the VDCG-FL framework, if AS executes the protocol honestly, clients can obtain a correct global model.

Proof. 

If AS executes the protocol honestly, clients can obtain a correct global model only if $y_1=y_2$.

If AS aggregates the global model honestly:

$$v_j^t=W^t\left[{\displaystyle \frac{\left(j-1\right)d}{m}}:{\displaystyle \frac{jd}{m}}\right]=\left({\displaystyle \frac{1}{m}}\sum _{j=1}^m{W}_{G_j}^t\right)\left[{\displaystyle \frac{\left(j-1\right)d}{m}}:{\displaystyle \frac{jd}{m}}\right]=u_j^t$$

(13)

Each relay client constructs the interpolation polynomials:

$$F\left(x\right)=\sum _{j=1}^m{v}_j^t{L}_j\left(x\right);$$

(14)

$$F\left(x\right)=\sum _{j=1}^m{v}_j^t{L}_j\left(x\right);G\left(x\right)=\sum _{j=1}^m{u}_j^t{L}_j\left(x\right)$$

(15)

where $L_j\left(x\right)$ is the Lagrange basis function.

Then the difference polynomial satisfies

$$H\left(x\right)=F\left(x\right)-G\left(x\right)=\sum _{j=1}^m{v}_j^t{L}_j\left(x\right)-\sum _{j=1}^m{u}_j^t{L}_j\left(x\right)=\sum _{j=1}^m(v_j^t-u_j^t)L_j\left(x\right)$$

(16)

If AS honestly executes the protocol, $v_j^t-u_j^t=0$ holds true for all j.

Therefore,

$$y_1-y_2=F\left(a^{*}\right)-G\left(a^{*}\right)=0;$$

(17)

$$y_1=y_2$$

(18)

From the above equations, we can conclude that if each entity honestly executes the protocol, the client can obtain the correct aggregated gradients to update the model. □

4.2. Latency Analysis

(a) Communication Latency Analysis without Verification

To better compare this work to FedAvg and Chain-PPFL, we only consider the functionality of grouping; the actual total overhead will be discussed in the next subsection.

In federated learning, the total latency of training round t consists of three components: (1) $T_{\mathrm{local}}^t$: the latency of local model updates; (2) $T_{\mathrm{global}}^t$: the latency for the aggregation server to compute the global model; (3) $T_{\mathrm{com},\mathrm{up}}^t$: the communication latency for uploading local models. For ease of analysis, in the FedAvg scheme, we assume that all clients have identical $T_{\mathrm{local}}^t$ and $T_{\mathrm{com},\mathrm{up}}^t$. Under this assumption, the per-round latency of FedAvg is given by

$$T_{\mathrm{total}}^t=T_{\mathrm{local}}^t+T_{\mathrm{global}}^t+T_{\mathrm{com},\mathrm{up}}^t.$$

(19)

In Chain-PPFL, the total latency of the training round t is composed of three parts: (1) $T_{\mathrm{local},\mathrm{chain}}^t$: the latency of local model updates; (2) $T_{\mathrm{global},\mathrm{chain}}^t$: the latency for the aggregation server to compute the global model; (3) $T_{\mathrm{com},\mathrm{chain}}^t$: the communication latency.

The communication latency $T_{\mathrm{com},\mathrm{chain}}^t$ consists of two parts: (1) the cumulative communication latency among clients along the chain $T_{\mathrm{com},\mathrm{sa}}^t$; (2) the latency of uploading the aggregated model to the server $T_{\mathrm{com},\mathrm{up}}^t$. For simplicity, we assume that the communication latency between two neighboring clients is the same and is denoted as $T_{\mathrm{com},\mathrm{nb}}^t$. Thus, the communication latency of Chain-PPFL can be expressed as

$$T_{\mathrm{com},\mathrm{chain}}^t=T_{\mathrm{com},\mathrm{sa}}^t+T_{\mathrm{com},\mathrm{up}}^t=(K-1)\times T_{\mathrm{com},\mathrm{nb}}^t+T_{\mathrm{com},\mathrm{up}}^t,$$

(20)

where K denotes the number of clients participating in each training round. Accordingly, the total latency of the Chain-PPFL scheme is

$$T_{\mathrm{total},\mathrm{chain}}^t=T_{\mathrm{local},\mathrm{chain}}^t+T_{\mathrm{global},\mathrm{chain}}^t+T_{\mathrm{com},\mathrm{chain}}^t.$$

(21)

In the VDCG-FL scheme, the latency of training round t also consists of three components: (1) $T_{\mathrm{local},\mathrm{vdcg}}^t$: the latency of local model updates; (2) $T_{\mathrm{global},\mathrm{vdcg}}^t$: the latency for the aggregation server to compute the global model; (3) $T_{\mathrm{com},\mathrm{vdcg}}^t$: the communication latency. All participating clients are divided into multiple groups, and different groups can operate in parallel. We assume that the local training latency in Chain-PPFL and VDCG-FL is identical:

$$T_{\mathrm{local},\mathrm{chain}}^t=T_{\mathrm{local},\mathrm{vdcg}}^t.$$

(22)

Regarding communication latency, we consider a single group as an example. The communication latency of VDCG-FL in round t, denoted as $T_{\mathrm{com},\mathrm{vdcg}}^t$, consists of the following: (1) $T_{\mathrm{com},\mathrm{g}}^t$, the communication latency among clients within the group; (2) $T_{\mathrm{com},\mathrm{up}}^t$, the latency of uploading the aggregated model to the server. Assuming identical neighbor communication latency $T_{\mathrm{com},\mathrm{nb}}^t$, which is the same as that of Chain-PPFL. So,

$$T_{\mathrm{com},\mathrm{vdcg}}^t=T_{\mathrm{com},\mathrm{g}}^t+T_{\mathrm{com},\mathrm{up}}^t=(S-1)\times T_{\mathrm{com},\mathrm{nb}}^t+T_{\mathrm{com},\mathrm{up}}^t,$$

(23)

where S denotes the number of clients in each group. Since all groups work in parallel, the total latency is dominated by the slowest group.

Thus, the total latency of VDCG-FL in one training round is given by

$$T_{\mathrm{total},\mathrm{vdcg}}^t=T_{\mathrm{local},\mathrm{vdcg}}^t+T_{\mathrm{global},\mathrm{vdcg}}^t+T_{\mathrm{com},\mathrm{vdcg}}^t.$$

(24)

Since both Chain-PPFL and VDCG-FL introduce the masking mechanism, the latency for computing local models is leading to

$$T_{\mathrm{local}}^t<T_{\mathrm{local},\mathrm{chain}}^t\approx T_{\mathrm{local},\mathrm{vdcg}}^t.$$

(25)

In Chain-PPFL, the aggregation server does not need to compute the sum or average of all individual updates, since aggregation is completed along the chain. In contrast, VDCG-FL requires the server to further aggregate the results from different groups. Therefore, we have

$$T_{\mathrm{global},\mathrm{chain}}^t<T_{\mathrm{global}}^t<T_{\mathrm{global},\mathrm{vdcg}}^t.$$

(26)

Regarding communication latency, the main bottleneck of Chain-PPFL lies in the long sequential communication path. By dividing clients into multiple groups and enabling parallel execution, VDCG-FL reduces the number of sequential communication operations. As a result, we obtain

$$T_{\mathrm{com},\mathrm{g}}^t<T_{\mathrm{com},\mathrm{sat}}^t.$$

(27)

We adopt the same latency analysis model as single-chain federated learning to ensure a fair comparison. In practice, system heterogeneity—stemming from differences in computation, hardware, and network conditions—is inevitable and affects communication latency. Nevertheless, the proposed Euclidean distance-based grouping strategy helps reduce communication overhead. Due to spatial correlation, geographically close clients tend to share similar network characteristics (e.g., latency, link quality, bandwidth). Thus, even under a simplified latency model, our approach demonstrates favorable communication performance. Moreover, an appropriate grouping number can reduce system latency without sacrificing model accuracy, striking a desirable balance between communication efficiency and model performance.

(b) Complexity Analysis of the Lagrange-Based Verification Mechanism

In the previous section, we only discussed the impact of grouping on latency. To discuss the overall framework overhead more comprehensively, we focus on verification overhead in this section. Throughout this analysis, d denotes the total dimension of the global model parameters, m denotes the number of groups (equivalently, the number of relay clients), so that each model slice has dimension ${\displaystyle \frac{d}{m}}$.

The main source of total overhead for verification mechanisms is the secure segment exchange conducted among all relay clients. Each relay client $R_j$ transmits $m-1$ vectors of dimension ${\displaystyle \frac{d}{m}}$ to the remaining relay clients, and receives $m-1$ vectors of the same dimension in return. Aggregating across all m relay clients, the total volume of data exchanged is $m\times (m-1)\times {\displaystyle \frac{d}{m}}=(m-1)\times d$, so the time complexity is $O\left(md\right)$.

Also, each relay client $R_j$ splits the $W_{G_j}^t$ and reconstructs the reference slice $u_j^t=v_j^t$. Since the dimension of each segment is ${\displaystyle \frac{d}{m}}$, the time complexity is: $O(m\times {\displaystyle \frac{d}{m}})=O\left(d\right)$. Similarly, the time complexity of calculating $y_1$ and $y_2$ is also $O\left(d\right)$ because the dimension of $v_j^t=v_j^t$ is ${\displaystyle \frac{d}{m}}$. In summary, the total per-relay-client complexity is $O\left(d\right)$. Therefore, the verification time complexity is independent of the number of groups m. No matter how many groups participate, the time complexity of each client remains O(d).

5. Comparative Experiment

This subsection assesses the performance of VDCG-FL by benchmarking it against FedAvg, Chain-PPFL, and G-VCFL. FedAvg is a widely used baseline that relies on centralized aggregation at the server and is suitable for evaluating federated learning in both IID and non-IID settings. Chain-PPFL exemplifies a chain-based strategy in which clients update their models in sequence, with only the final client communicating with the server. G-VCFL enhances scalability and training efficiency by organizing clients into multiple groups as part of a verifiable federated learning framework. We further examine the impact of different group sizes on VDCG-FL’s accuracy and test its robustness across various levels of data heterogeneity.

5.1. Dataset

To evaluate training accuracy, experiments were carried out on two widely used datasets: MNIST and CIFAR-10. MNIST consists of 70,000 grayscale handwritten digit images with a resolution of $28\times 28$. Among them, 60,000 images are used for training and 10,000 for testing. Each image belongs to one of 10 classes labeled 0–9. Thanks to its simple structure and low noise, MNIST is commonly used to evaluate model convergence and stability. CIFAR-10, by comparison, includes 60,000 RGB images of size $32\times 32$, with 50,000 for training and 10,000 for testing. Its higher complexity and diverse sample distribution make CIFAR-10 well-suited for assessing model generalization, particularly in Non-IID scenarios.

5.2. Experimental Setup

The experiments employed two well-established neural network architectures: Convolutional neural networks (CNNs) and multilayer perceptrons (MLPs). The CNN model comprises three convolutional layers with 32, 64, and 128 channels, each followed by batch normalization, ReLU activation, and max pooling for effective feature extraction and spatial downsampling. The model’s output layer uses a log-softmax function to enhance numerical stability. The MLP architecture consists of four fully connected layers, incorporating ReLU activations and dropout between layers to boost nonlinearity and reduce overfitting.

For dataset partitioning, MNIST samples are first normalized and then divided into IID and non-IID configurations. In the IID scenario, data are shuffled randomly and evenly distributed among clients. In the non-IID scenario, data are sorted by class labels and split into multiple shards, assigning each client a limited set of classes to simulate non-independent distributions. Experiments with both MLP and CNN models are conducted on the MNIST and CIFAR-10 datasets. All experiments were run on a PC equipped with an AMD Ryzen 7 5800H processor with Radeon Graphics (3.20 GHz) and 16 GB of RAM.

We implemented the VDCG-FL scheme using Python and built neural network models with PyTorch. The federated learning aggregation process follows the FedAvg algorithm. The experimental setup is detailed in

Table 2. Experimental Parameter Settings.

Parameter	Description	Value
N	Number of clients	100
B	Local minibatch size	10
E	Number of local epochs	20
$\eta$	Learning rate	0.001

below.

5.3. Experimental Results

This section examines how the number of groups affects VDCG-FL, compares the accuracy of VDCG-FL with FedAvg, Chain-PPFL, and G-VCFL, and evaluates VDCG-FL’s performance under varying levels of heterogeneity.

5.3.1. Group Size vs. Model Accuracy

To evaluate the effect of the grouped chain structure on model performance, we conducted experiments on the MNIST dataset using both MLP and CNN models, and compared training accuracy across various group counts. Accuracy is assessed under six conditions: MNIST CNN Non-IID, MNIST CNN IID, MNIST MLP Non-IID, MNIST MLP IID, CIFAR-10 CNN IID, and CIFAR-10 MLP IID. Among them, MNIST CNN Non-IID denotes a CNN-based federated learning approach on the MNIST dataset with non-IID data, and the remaining cases follow similar definitions. In all experiments, the client count is fixed at $N=100$, with group sizes of 5, 10, 20, 25, and 50. All other hyperparameters remained constant to isolate the impact of grouping on convergence speed and final global model accuracy.

a. Under the Non-IID Setting

We analyze how group size affects model accuracy in a non-IID MNIST setting, seen in Figure 2. The training process and final convergence performance are reported for both CNN and MLP models with group sizes of 5, 10, 20, 25, and 50.

Figure 2 shows that, under the Non-IID setting, the overall trend of model accuracy for different group sizes increases gradually with the training rounds and becomes stable after approximately 80 to 100 rounds. All group configurations ultimately reach a high accuracy, demonstrating that the grouping strategy does not hinder global model convergence. From Figure 2a, it can be observed that in the MNIST CNN Non-IID setting, the final test accuracies for different group sizes achieve an accuracy close to 99%. The zoomed-in view further reveals that using 20 or 25 groups yields slightly better accuracy than 5 or 10 groups after convergence. In the MNIST MLP Non-IID setting, group size has a more pronounced impact on model performance. With fewer groups, such as 5 or 10, the model converges more quickly during the initial training phase, but its final accuracy is somewhat lower. Increasing the group count to 20 or 25 improves test accuracy throughout training and results in more stable convergence.

b. Under the IID Setting

We investigate how group size affects model accuracy on the MNIST and CIFAR-10 datasets in the IID scenario. Figure 3 presents the test accuracy for various group sizes under IID data partitioning. Experiments are performed on both MNIST and CIFAR-10 using two model architectures, CNN and MLP, for comparison. The group sizes evaluated include 5, 10, 20, 25, and 50.

Figure 3a demonstrates that, in the MNIST IID setting, the CNN model converges quickly across all group size configurations, stabilizing after about 20–30 rounds. All group sizes yield a final test accuracy above 99%. The zoomed-in plot reveals only minor differences in accuracy and small fluctuations between group sizes. Configurations with 20 or 25 groups slightly outperform those with 5 or 10 groups after convergence.

Figure 3b illustrates that, in the MNIST MLP IID setting, the model consistently converges quickly for all group sizes, reaching stability after approximately 50 rounds. Group sizes of 10, 20, and 25 yield marginally higher final test accuracy compared to the 5-group configuration, while results with 50 groups are similar to those with intermediate sizes. The MLP model displays slightly greater sensitivity to group-size variations than the CNN model in IID scenarios, though overall accuracy differences remain small.

Figure 3c,d presents results for the CIFAR-10 CNN IID and CIFAR-10 MLP IID experiment. While overall accuracy is lower than on MNIST due to CIFAR-10’s higher complexity, convergence patterns are comparable across group sizes. Group sizes of 10 and 20 achieve slightly better test accuracy in later training, whereas using 5 or 50 groups leads to modestly reduced performance.

The above experimental results demonstrate that the group-based chain federated learning framework shows good adaptability under different data distributions and model architectures. Different group sizes yield unique convergence patterns and affect final accuracy. To pinpoint the most effective group configurations for practical applications, the next set of experiments provides a comprehensive analysis that incorporates system performance metrics such as communication latency. These findings are discussed in the following sections.

5.3.2. Group Size vs. Latency Analysis

This subsection explores the impact of different client group sizes on average round latency. Results are compared with Chain-PPFL, which operates with a single chain, and Chain-PPFL with verification. Unlike this method, VDCG-FL divides clients into several groups and performs chain-based training within each group in parallel, enhancing overall efficiency. Experiments are conducted on the MNIST dataset under both IID and non-IID conditions, using CNN and MLP architectures. The detailed results are shown in

Table 3. Latency comparison on MNIST under different models and data distributions.

Method	Group	Verification	Non-IID		IID
			MLP	CNN	MLP	CNN
ChainPPFL	no	no	42.3278	63.6973	44.3345	50.4423
ChainPPFL-Verify	no	yes	320.9824	378.8209	203.4054	317.1838
VDCF-FL-2	yes	yes	29.7893	61.9866	41.0304	49.8856
VDCF-FL-5	yes	yes	30.3373	62.1330	42.2652	43.0279
VDCF-FL-10	yes	yes	31.7135	56.1463	32.1340	44.7566
VDCF-FL-15	yes	yes	47.4470	72.1167	44.6895	70.1384
VDCF-FL-20	yes	yes	69.1029	97.8918	66.0774	73.9705
VDCF-FL-25	yes	yes	74.8253	120.4674	96.4678	109.6210
VDCF-FL-50	yes	yes	156.9072	223.4057	156.4072	207.8519

.

These results compare the average latency of various methods on the MNIST dataset, evaluated under both IID and Non-IID conditions using MLP and CNN models. Compared to Chain-PPFL with verification, our method significantly reduces latency. This is because the Lagrange interpolation verification method used in the chained structure requires verification by each client, increasing computational overhead. Our grouping scheme reduces the number of verifications, thereby reducing latency. In VDCG-FL, clients are organized into groups of 2, 5, 10, 15, 20, 25, or 50. When the number of groups is relatively small (e.g., 2, 5, and 10), VDCG-FL achieves much lower latency than the single-chain Chain-PPFL. For instance, for the MLP model under an IID MNIST setting, VDCG-FL with 10 groups reduces the average per-round latency from 44.33 s to 32.13 s, a decrease of approximately 27.5%. Similarly, under the non-IID MNIST setting, the two-group configuration achieves the lowest per-round latency, reducing it to 29.79 s and outperforming the single-chain approach by approximately 29.6% compared to the single-chain approach. These results indicate that moderate group size with parallel execution effectively shortens the per-round training time and alleviates the straggler effect inherent in serial single-chain participation. However, as the number of groups increases further (e.g., 15, 20, 25, and 50), system latency increases substantially.

In summary, the experimental results demonstrate that the grouping-based parallel mechanism effectively reduces the training latency of federated learning. However, these good performances highly depend on the number of groups. A moderate number of groups (e.g., 2 to 10) provides a favorable trade-off between communication efficiency and model performance. This degradation is mainly due to the fewer clients per group, which results in more frequent synchronization and higher communication overhead, ultimately reducing overall system efficiency.

5.3.3. Comparison with Previous Schemes

To evaluate the classification accuracy of VDCG-FL, we do some experiments on two public datasets, MNIST and CIFAR-10, to compare VDCG-FL with previous classic schemes: FedAvg, Chain-PPFL, and G-VCFL. These experiments are carried out under six situations: MNIST CNN IID, MNIST CNN Non-IID, MNIST MLP IID, MNIST MLP Non-IID, CIFAR-10 CNN IID, and CIFAR-10 MLP IID. Previous experiments indicate that setting the group count to 10 or 20 enables VDCG-FL to achieve superior accuracy and faster convergence compared to other configurations. However, latency analysis shows that the 10-group setup results in much lower latency than the 20-group alternative. To strike an optimal balance between accuracy and latency, we select 10 groups for the comparison experiments with FedAvg, Chain-PPFL, and G-VCFL. In these experiments, the total number of clients is fixed at $N=100$, with each group consisting of $S=10$ clients.

a. Under the Non-IID Setting

Figure 4 displays the test accuracy of FedAvg, Chain-PPFL, G-VCFL, and the proposed VDCG-FL on the MNIST dataset with Non-IID data, evaluated using both CNN and MLP models. For the CNN model (Figure 4a), all methods show increasing accuracy as training progresses, but VDCG-FL converges the fastest, stabilizes sooner, and attains the highest final accuracy. This demonstrates VDCG-FL’s strong convergence and robustness. For the MLP model (Figure 4b), Chain-PPFL and G-VCFL deliver moderate improvements over FedAvg but experience considerable fluctuations early in training. In contrast, VDCG-FL not only converges more quickly but also achieves higher and more stable final accuracy.

b. Under the IID Setting

Figure 5 shows the test accuracy of FedAvg, Chain-PPFL, G-VCFL, and the proposed VDCG-FL on the MNIST and CIFAR-10 datasets under IID conditions, using both CNN and MLP models.

For MNIST (Figure 5a,b), all four methods achieve rapid convergence and high test accuracy within a few training rounds. VDCG-FL stands out by converging even faster in the early stages and maintaining higher accuracy throughout training. FedAvg and Chain-PPFL display similar trends and final accuracy, while G-VCFL lags initially but eventually catches up.

For CIFAR-10 (Figure 5c,d), the increased complexity results in lower overall accuracy compared to MNIST, but performance differences among methods are more pronounced. VDCG-FL quickly boosts model accuracy in the early rounds and consistently maintains the highest accuracy in the middle and later stages. In contrast, G-VCFL and Chain-PPFL converge more slowly. These results highlight VDCG-FL’s superior convergence stability and generalization ability, particularly on more challenging datasets.

The above results show that VDCG-FL achieves higher accuracy and more efficient communication than these methods. This indicates that the grouping and verification strategy do not degrade model performance, but instead improve training stability and model accuracy. Grouping clients by distance helps reduce the length of each chain, thereby reducing error accumulation during serial model transmission and improving convergence performance. In addition, the verification mechanism based on Lagrange interpolation does not modify the model parameters but only verifies the correctness of the aggregation results. Therefore, it does not negatively affect model accuracy. These factors together explain why the proposed method can maintain or even improve model accuracy compared with the baseline methods.

5.3.4. Robustness Analysis Under Different Data Heterogeneity Levels

The VDCG-FL scheme organizes clients according to their Euclidean distance from the server. This approach is grounded in the observation that spatially proximate clients typically possess similar communication capacities. Unlike random grouping, distance-based grouping leverages the physical network topology, enabling spatially close clients to form groups. This results in similarity in communication distance within each group and fosters more stable local aggregation.

In federated learning, data heterogeneity is a fundamental challenge that affects model convergence and performance. Although the proposed grouping strategy is designed from a communication perspective, it is necessary to evaluate its effectiveness under different non-IID settings. Therefore, we adopt the Dirichlet-based partitioning strategy to simulate varying degrees of data heterogeneity and assess the robustness of the proposed method. Adjusting the Dirichlet parameter $\alpha$ controls the level of heterogeneity: smaller $\alpha$ values create more imbalanced data distributions and greater heterogeneity, while larger values approach the IID case. In our experiments, $\alpha$ values of $0.05$, $0.1$, and $0.5$ represent strong, moderate, and weak heterogeneity, respectively. It should be noted that the proposed distance-based grouping strategy is not designed to reduce data heterogeneity. Instead, the experiments in this section are designed to evaluate the robustness of this approach under different levels of heterogeneity; however, the grouping strategy proposed in this paper is primarily intended to reduce communication overhead on the client side. By grouping clients that are physically close together, the impact of network links on communication latency can be effectively minimized.

Building on the previous experimental results, this section aims to balance latency and accuracy by selecting VDCG-FL with 10 groups for further evaluation.

A. Convergence Performance Comparison under Different Heterogeneity Levels

Figure 6a–f illustrates that both VDCG-FL and Chain-PPFL achieve convergence within a limited number of training rounds across various experimental settings. However, notable performance differences emerge under strong data heterogeneity.

For strong data heterogeneity ($\alpha =0.05$), both the CNN and MLP models indicate that Chain-PPFL exhibits significant instability during the first 20 training rounds, with accuracy curves showing pronounced fluctuations. In contrast, the grouping mechanism of VDCG-FL helps mitigate the adverse effects of high heterogeneity, resulting in more stable model training.

When $\alpha =0.1$, data heterogeneity is less pronounced, and both methods exhibit more stable convergence than in the $\alpha =0.05$ scenario. Nevertheless, VDCG-FL continues to demonstrate smoother convergence than Chain-PPFL during the early training phase.

With weak heterogeneity ($\alpha =0.5$), the performance gap between the two approaches narrows considerably, and their accuracy curves nearly overlap.

B. Impact of Different Heterogeneity Levels on VDCG-FL

Figure 7a,b shows how varying levels of data heterogeneity affect VDCG-FL’s training process. As the Dirichlet parameter $\alpha$ decreases—signaling increased data heterogeneity—the final convergence accuracy of VDCG-FL declines. Nevertheless, VDCG-FL consistently converges more stably and to higher accuracy than the single-chain structure, even when $\alpha =0.05$, maintaining a clear and stable convergence pattern throughout training.

With $\alpha$ increased to $0.5$, both convergence speed and final accuracy improve further. These findings highlight the adaptability and robustness of the distance-based grouping mechanism across varying degrees of data heterogeneity.

In summary, the experimental results show that VDCG-FL delivers greater training stability and improved convergence compared to Chain-PPFL, especially under strong data heterogeneity. Under weaker heterogeneity, VDCG-FL performs at least as well as Chain-PPFL, without any loss in performance. Although the grouping strategy proposed in this paper is an optimization scheme designed from the perspective of communication latency and cannot directly address the issue of statistical heterogeneity caused by non-iid data, it still exhibits good convergence performance and high accuracy in the data heterogeneity experiments presented in this subsection.

6. Conclusions

In this paper, we propose VDCG-FL, a verifiable grouped chain-based framework for privacy-preserving federated learning. Clients are grouped based on the Euclidean distance between clients and the aggregation server, enabling the federated learning system to construct a more reasonable training and model-uploading order in communication-heterogeneous environments. This grouping strategy mitigates the effects of system heterogeneity and ensures the stability of system convergence. Interpolation methods effectively lower computational overhead. Compared with traditional federated learning schemes, VDCG-FL shows improved training stability and faster convergence. Although the proposed VDCG-FL framework addresses the problems of aggregation reliability and communication overhead, there are still some limitations. Handling client dropout and dynamic network conditions will be an important direction for future work. Moreover, enhancing the robustness and scalability of the proposed framework against poisoning attacks and other adversarial behaviors will be another important direction of our future research.