Layerwise Federated Learning for Heterogeneous Quantum Clients using Quorus

## Abstract

Abstract Quantum machine learning (QML) holds the promise to solve classically intractable problems, but, as critical data can be fragmented across private clients, there is a need for distributed QML in a quantum federated learning (QFL) format. However, the quantum computers that different clients have access to can be error-prone and have heterogeneous error properties, requiring them to run circuits of different depths. We propose a novel solution to this QFL problem, Quorus , that utilizes a layerwise loss function for effective training of varying-depth quantum models, which allows clients to choose models for high-fidelity output based on their individual capacity. Quorus also presents various model designs based on client needs that optimize for shot budget, qubit count, midcircuit measurement, and optimization space. Our simulation and real-hardware results show the promise of Quorus: it increases the magnitude of gradients of higher depth clients and improves testing accuracy by 12.4% on average over the state-of-the-art.

## 1 Introduction

Quantum machine learning (QML) holds the potential to solve classically difficult problems with high efficiency. Existing methods using quantum ML have been applied to a variety of industrial and scientific applications, including portfolio optimization, drug discovery, and weather forecasting (Peral-García et al., 2024; Smaldone et al., 2025; Liu et al., 2025). Quantum ML has also been used to solve classical ML problems with significant reductions in parameters (Kashif et al., 2025; DiBrita et al., 2025; Leither et al., 2025). Given the success of quantum ML, a natural consideration, like in classical ML, is to consider the real-world case of fragmented data across multiple private clients. How can clients with quantum computers train together, without revealing data to other parties? The classical analog of solving this problem has also been proposed, called Quantum Federated Learning (QFL) (Chen & Yoo, 2021).

However, existing QFL techniques do not consider the heterogeneity of quantum devices. All quantum computers are subject to hardware error that varies from computer to computer, which has continued to be a critical challenge in quantum computing (Tannu & Qureshi, 2019; Montanez-Barrera et al., 2025). The quantum computing research community has proposed Quantum Error Correction (QEC) as a solution to quantum hardware error (Calderbank & Shor, 1996; Acharya et al., 2024); however, QEC techniques require millions of qubits, which will not exist for many years (Gidney & Ekerå, 2021; Sevilla & Riedel, 2020). Thus, in our current day, to use error-prone devices for QML tasks, one strategy is to limit the depth of the circuit (quantum code) that is executed on the hardware, as the error manifested in the output of the circuit is proportional to its depth. Reducing the depth of the circuit is particularly important, as a major source of quantum errors is decoherence, where a qubit loses its important amplitude and phase information with respect to time (Schlosshauer, 2019; Zurek, 2003; Preskill, 2018). By keeping the circuit to a reasonably shallow depth, researchers attempt to utilize existing quantum computers to achieve practical quantum utility today.

Another challenge in QML is the barren plateaus problem, where gradients vanish as the circuit depth grows (Anschuetz, 2025; Yan et al., 2024; Patel et al., 2024). In the worst case, gradients decay exponentially, making it practically impossible to train deep circuits, even when noise is not the dominating factor (Cerezo et al., 2021). This significantly restricts the scalability of QML circuits, as optimization becomes infeasible beyond moderate depths. A further obstacle is resource efficiency. Unlike classical training, which can rely on inexpensive iterations, every quantum training step requires repeated circuit executions (shots) to estimate observables (McClean et al., 2016). As a result, algorithms must be designed to minimize the number of shots needed for accurate training to ascertain the economic viability for real-world QML.

To address the above challenges, in this work, we design an error-aware QFL technique, Quorus, by considering that clients can only run quantum circuits of particular depths, based on the depth at which they can achieve reasonably high accuracy to participate in FL. We illustrate our overall setup in Fig. [1](https://arxiv.org/html/2510.06228v1#S1.F1). While existing QFL works have shown that if training is done in the presence of noise that corrupts the output, then the final training accuracy degrades with depth (Rahman et al., 2025; Sahu & Gupta, 2024), our goal is to enable clients to run as many layers as possible, to allow for higher expressive power and thus, higher accuracy (Sim et al., 2019). Quorus is the first-of-its-kind work that utilizes layerwise loss functions and knowledge distillation for synchronized objectives across heterogeneous-depth clients. We propose novel shot-efficient designs for varying quantum hardware capabilities and demonstrate both higher gradient magnitudes as well as implementations on all of IBM’s state-of-the-art superconducting quantum computers.

The contributions of this work are as follows:

- •
The first structured quantum federated learning framework (Quorus) that utilizes layerwise losses and reverse distillation for improved accuracy (to the best of our knowledge).
- •
A quantum model architecture whereby an ensemble of quantum classifiers can be obtained from a single shot of a quantum circuit, leading to both higher accuracy and resource efficiency.
- •
A design that improves testing accuracy by up to 12.4% over Q-HeteroFL (Diao et al., 2021)while being shot-efficient for different binary classification tasks.
- •
A model that yields higher gradient norms, reducing barren plateau effect, and achieves accuracy within 3% of ideal simulation on IBM superconducting QPUs, showing real-world viability.
- •
The code and dataset of Quorus are open-sourced at: [https://github.com/positivetechnologylab/Quorus](https://github.com/positivetechnologylab/Quorus).

Figure: Figure 1: Depiction of the overall setup of our depth-heterogeneous quantum FL framework. Our setup utilizes the realistic scenario of a classical network for sending and receiving parameters, and each client has a quantum computer that can run circuits of varying depths.
Refer to caption: x1.png

## 2 Preliminaries

Quantum Computing Basics. Quantum computers process information by manipulating qubits with quantum circuits. The state of a qubit is represented as a vector: $\ket{\psi}=\beta_{0}\ket{0}+\beta_{1}\ket{1}$, where $\beta_{0},\beta_{1}\in\mathbb{C}$ and $|\beta_{0}|^{2}+|\beta_{1}|^{2}=1$. The state $\ket{\psi}$ exists in a superposition of the states $\ket{0}$ and $\ket{1}$, which encodes the quantum data we process. The probability of measuring the qubit to be in state $\ket{i}$ is $p(i)=|\beta_{i}|^{2}$, meaning we must have $|\beta_{0}|^{2}+|\beta_{1}|^{2}=1$. A statevector of a system of $n$ qubits is a complex vector in the Hilbert space $\ket{\psi}\in\mathbb{C}^{2^{n}}=\mathcal{H}_{n}$, that is normalized $\braket{\psi|\psi}=1$. We can write our state in the computational basis: defining $b_{k}$ as the bitstring corresponding to the integer $k$, the computational basis is the set $\{\ket{b_{k}}\forall k\in\mathbb{Z},0\leq k\leq 2^{n-1}\}$. Our state can be expressed as $\ket{\psi}=\sum_{k=0}^{2^{n-1}}\beta_{k}\ket{k}$. The quantum data $\ket{\psi}$ is processed by a quantum circuit $U$, a unitary operator taking $U\ket{\psi_{1}}=\ket{\psi_{2}}$. Because $U$ is unitary, it is reversible ($UU^{\dagger}=U^{\dagger}U=I$).

Parameterized Quantum Circuits. To frame a learning problem on quantum computers, we parameterize the operation $U$ with parameters $\theta$, which are typically rotation angles on the Bloch sphere. Then, $U(\theta)$ is a parameterized quantum circuit (PQC) with trainable gate parameters, and the structure of $U(\theta)$ is referred to as an ansatz. These variational quantum circuits are often composed of repeated circuit structures called layers, and can be written as $U(\theta)=U_{0:L}(\theta_{0:L})=U_{L}(\theta_{L})U_{L-1}(\theta_{L-1})...U_{0}(\theta_{0})$, where $U_{i}$ is the parameterized circuit for layer $i$, with parameters $\theta_{i}$. Deeper circuits are more expressive, but also suffer from decoherence and errors when evaluated on real hardware. Quantum machine learning generally aims to solve the following problem for an objective $L$ and input data $x$: $\theta^{\star}\;=\;\operatorname*{arg\,min}_{\theta\in\Theta}\;L\!\left(U,x;\theta\right)$. To evaluate $L\!\left(U,x;\theta\right)$ on a quantum computer, it is performed by estimating $p(b)$, the probability of measuring state $\ket{b}$ via running the circuit $U(\theta)$ multiple times, and tracking how many times the outcome $b$ was observed. Each run of the quantum circuit is called a shot, and shots are expensive on current-day quantum hardware.

Quantum Measurements. The objective $L$ of a parameterized circuit is extracted via projective measurement, which is irreversible in general. For a particular outcome $b\in\{0,1\}$, if the first qubit in state $\ket{\psi}$ is measured to be $b$, then the resulting state is collapsed to $\ket{\psi_{b}}=\frac{1}{\sqrt{p(b)}}\sum_{k:k_{1}=b}\beta_{k}\ket{k}$. This fundamental quantum property poses a unique challenge when the objective $L_{j}$ is defined for each layer, so $L_{j}=L(U_{0:j};\theta_{0:j})$, where $U_{0:j},\theta_{0:j}$ represents the layers and parameters up to layer $j$. Because measuring a qubit collapses the superposition and removes information from the quantum state, it poses a challenge for simultaneously collapsing information via measurement and retaining sufficient information for subsequent quantum layers and operations (Gyawali et al., 2024).

Heterogeneous Federated Learning. Federated learning (FL) is a distributed machine learning technique widely used in classical ML where each client’s data is private to themselves (McMahan et al., 2023). The overall objective function in federated learning for $m$ clients is $L(x_{1},x_{2},...,x_{m})=\frac{1}{m}\sum_{i=1}^{m}L_{i}(x_{i})$, where $x_{j}$ represents the data of client $j$ and $L_{j}$ is the loss function for client $j$ (McMahan et al., 2023). In centralized federated learning, training is done locally by clients, and parameters are aggregated in a centralized server and broadcast back to clients. An intuition may be gained for why parameter aggregation works by observing that, in the special case where stochastic gradient descent (SGD) is used, parameters are aggregated every epoch, and the batch size is equal to the amount of data a client has, it is equivalent in expectation to performing SGD on the centralized objective $L$ (McMahan et al., 2023).

Heterogeneous Federated Learning adds a layer of complexity to FL by allowing for clients to have different local model architectures (Diao et al., 2021). This scenario accounts for the case where some clients have differential computational abilities, but still want to take advantage of FL to obtain a shared model. Because the parameter spaces of models are now different, special considerations need to be made as the differing model architectures lead to parameter mismatches that can negatively affect training (Kim et al., 2023). Refer to Appendix [A](https://arxiv.org/html/2510.06228v1#A1) for further details.

## 3 Related Work

Classical Federated Learning.
The problem of depth-heterogeneous quantum federated learning, where clients have classical models, has a large body of work in the literature, but many state-of-the-art techniques in classical FL cannot be directly applied to the case where the model is a PQC. The classical model-heterogeneous FL technique, HeteroFL (Diao et al., 2021), aggregates parameters in shared submodels across clients. Since this original work, some newer techniques have been proposed, namely FEDepth and ScaleFL (Zhang et al., 2025; Ilhan et al., 2023), which assume that intermediate layers can be trained; however, this is not applicable to PQC’s as training these layers requires a client to run circuits to that depth, which precisely is the bottleneck in quantum circuits.

Another work, ReeFL, uses a transformer to fuse features between layers; however, features are not directly accessible in quantum ML unless via state tomography (Lee et al., 2024). The classical work most closely related to Quorus, DepthFL (Kim et al., 2023), is amenable to the setup of quantum clients with models of varying depths as it is a layerwise FL technique; however, evaluating the layerwise loss function on quantum computers is nontrivial due to measurement collapse, which we discuss further in Sec. [4.3](https://arxiv.org/html/2510.06228v1#S4.SS3). Overall, these classical works cannot be directly applied to the quantum FL setup and highlight the importance of quantum-centric design, which we propose in this work.

Quantum Federated Learning. The overall setup of QFL, where clients use the same architecture PQC and use a centralized server for parameter aggregation, has been studied (Chen & Yoo, 2021); however, the problem of depth-heterogeneous FL is not well studied in the quantum case. One work that tackles the problem of parameters being lost in communication, named eSQFL (Yun et al., 2022), uses a layerwise loss function by computing the inner product of states between each layer; however, computing inner products requires long-distance connectivity and is not applicable to run on real hardware (Sá et al., 2023). There is a gap in the literature related to quantum federated learning for clients with heterogeneous needs, which we propose a solution for in this work.

## 4 Design and Approach

The overall workflow of our technique is illustrated in Fig. [1](https://arxiv.org/html/2510.06228v1#S1.F1). Each client is able to train a PQC of a different depth based on its hardware capability. After local training, clients send their parameters to a server over a classical network, where parameters are aggregated and sent back to clients. Clients then continue to train locally, repeating the process for a set number of rounds.

Figure: Algorithm 1 Quorus

### 4.1 Quorus Workflow

A detailed description of our workflow is depicted in Algorithm [1](https://arxiv.org/html/2510.06228v1#alg1) (Kim et al., 2023). Because PQC’s have heterogeneous depths, parameters are aggregated only among the clients that share each parameter. We also perform aggregation of parameters with circular averaging because the quantum circuit parameters in our implementation are rotation angles, where the angle function is defined as angle($z$) = atan2(imag($z$), real($z$)). The layerwise loss function for client k is

$$ $\textstyle L_{k}=\sum_{i=1}^{d_{k}}L^{i}_{\mathrm{ce}}\;+\;\frac{1}{d_{k}-1}\sum_{i=1}^{d_{k}}\sum_{\begin{subarray}{c}j=1,\ j\neq i\end{subarray}}^{d_{k}}\mathrm{D}_{\mathrm{KL}}(p_{j}\,\|\,p_{i}),$ (1) $$

where $L^{i}_{\mathrm{ce}}$ is the Binary Cross Entropy loss for the classifier at depth $i$. Note, then, that this loss function assumes that there is a means to extract classifier outputs at each layer – an important problem with a unique quantum design (addressed in Sec. [4.3](https://arxiv.org/html/2510.06228v1#S4.SS3)). $d_{k}$ is the depth of client $k$ and $\mathrm{D}_{\mathrm{KL}}(p_{j}\,\|\,p_{i})$ is the KL divergence between logits $p_{i}$ and $p_{j}$. We use the same loss function as in DepthFL (Kim et al., 2023), because a similar intuition applies: we want a loss function that clients share to address parameter mismatching, where parameters are different across clients due to varying local parameter spaces. In addition, we want to use the KL divergence for “reverse distillation”, whereby deeper classifiers are helped by shallower ones. These nuances are explored and justified in  (Kim et al., 2023), so we do not repeat the discussion for the quantum case.

The unique challenge in the quantum case is how exactly to evaluate the loss in Eq. [1](https://arxiv.org/html/2510.06228v1#S4.E1). In our setup for Quorus, the loss $L^{i}_{\mathrm{ce}}$ is computed via the probability of measuring a qubit to be 0 or 1 for our binary classification tasks. This poses unique quantum-specific design considerations for Quorus, which the following sections will be devoted to solving.

### 4.2 Ansatz Designs and Selection

Figure: (a)
Refer to caption: x2.png

For any quantum computing problem, it is well-known that deciding the ansatz is essential (Sugisaki et al., 2022), for two main reasons. Firstly, it determines the expressibility and the space of solution states that are explored, and because of the exponentially-sized Hilbert space that quantum computers operate in, operating in a relevant subspace is essential (Sim et al., 2019; Yan et al., 2024; Holmes et al., 2022). Secondly, it is entirely possible to find an ansatz that is well-suited for the problem of interest, but is very inefficient when implemented on hardware architectures with limited connectivity due to its use of long-distance two-qubit or multi-qubit gates, causing high levels of output error (Kivlichan et al., 2018; Romero et al., 2018). We address these problems by systematically exploring relevant ansätze for our problem, depicted in Fig. [2](https://arxiv.org/html/2510.06228v1#S4.F2). In each layer of our ansatz, we perform data reuploading as it has been shown in multiple quantum ML experiments to yield improved accuracy and nonlinearities with respect to the input (Vidal & Theis, 2020; Aminpour et al., 2024). We use the Ry gate to achieve this. We use layers of generalized single-qubit gates Rot as tunable parameters. The ansatzes we design are centered around two main principles:

Figure: (a)
Refer to caption: x4.png

(1) The ansatz must be hardware efficient, so we assume only nearest-neighbor connectivity as observed in quantum hardware (Huo et al., 2025; Han et al., 2025), and (2) only the first qubit is measured to obtain the output statistic. The latter choice is because we focus on binary classification tasks in this work, so measuring a single qubit is sufficient (Schuld et al., 2020). Thus, we come up with two relevant ansätze: the first is the Staircase ansatz, depicted in Fig. [2](https://arxiv.org/html/2510.06228v1#S4.F2)(a) (Schuld et al., 2020; Sim et al., 2019), which has a staircase of CNOTs from the last qubit up to the first one.

Figure: Figure 4: The Quorus-Layerwise design. The circuit must be run $L$ times, where $L$ is the number of layers.
Refer to caption: x6.png

The second is the V-shaped ansatz, which has a staircase of CNOTs going down from the first to the last qubit, which then go back up to the first qubit, and the third is an alternating combination of the two. Based on our experimental evaluation on various datasets in (Appendix [D](https://arxiv.org/html/2510.06228v1#A4)), we observe that the V-shaped ansatz performs the best in a majority of the evaluations, and so we use it as the default ansatz. The reason that the V-shaped ansatz performs well is its ability to broadcast information throughout qubits with more CNOT gates traversing up and down the qubits (Sim et al., 2019).

### 4.3 Quantum Classifier Design

When one attempts to implement the layerwise loss function in Eq. [1](https://arxiv.org/html/2510.06228v1#S4.E1), there is an immediate problem: if we measure the qubit, then how can we pass on the same state to the next layer? An illustration of this dilemma is in Fig. [3](https://arxiv.org/html/2510.06228v1#S4.F3). In DepthFL and other classical works that assume an intermediate classifier, depicted in Fig. [3](https://arxiv.org/html/2510.06228v1#S4.F3)(a), the data after the first layer is somehow converted to a scalar, and implicitly, the data is passed, unchanged, to the next layer (and this “copy” operation has minimal classical overhead). Fundamentally, a direct analog does not exist in quantum computation. In quantum computing, if we measure one of the qubits mid-computation, this collapses the superposition on the first state and changes the state that is later used in computation (as represented in Fig. [3](https://arxiv.org/html/2510.06228v1#S4.F3)(b)). Passing the state unchanged thus requires you to prepare another copy of it, which induces additional shot overhead that is linear in the number of layers and is a nontrivial cost, given the expense of running quantum computers. For example, running quantum circuits for just one minute on an IBM quantum computer costs $\mathdollar 96$ (can run $\approx 30$ circuits in this time with 1k shots each) (ibm,). Thus, we are posed with an important question: How do we implement this measurement between layers in a quantum ML model, in a shot-efficient manner?

Figure: Figure 5: The Quorus-Ancilla design. The circuit is only run once, but requires an ancilla qubit per layer, and also dephases the first qubit.
Refer to caption: x7.png

Solution 1: Layerwise. The most straightforward solution to the classical case is to “copy” the quantum state, because we know exactly the circuit that prepared it. This solution is depicted in Fig. [4](https://arxiv.org/html/2510.06228v1#S4.F4). However, this requires a shot budget that scales linearly with the number of layers. For deep circuits, the required shot budget quickly becomes infeasible for budget-constrained clients.

Figure: (a)
Refer to caption: x8.png

Solution 2: Ancilla/Blocking. To address the case where a client does not have a high-shot budget, we design an ansatz where it is possible to obtain the outputs from all layers in a single shot. In particular, with reference to Figure [3](https://arxiv.org/html/2510.06228v1#S4.F3)(b), we propose continuing to operate on the collapsed state in our PQC. This design is depicted in Fig. [5](https://arxiv.org/html/2510.06228v1#S4.F5). In particular, we entangle the first qubit with an ancilla in the $\ket{0}$ state after each layer. We evaluate each layer’s outputs by computing the marginal distribution on its ancilla. For the first layer, the statistics match the Layerwise model; for later layers, they differ because entangling the first qubit with an ancilla “dephases” it (Gyawali et al., 2024). Since dephasing is limited to that qubit, we hypothesize, and confirm on IBM hardware (Sec. [5](https://arxiv.org/html/2510.06228v1#S5)), that our quantum ML model can still train effectively under this alternative model. Implementing this requires the first qubit to entangle with a new ancilla at each layer, which in turn demands long-distance CNOTs. Thus, while our Layerwise ansatz assumes nearest-neighbor connectivity, systems with larger qubit counts and richer connectivity can benefit from this Ancilla approach. In principle, ancillae are not required – one can simply just measure the first qubit, not reset it, and continue in computation. This logically equivalent (proof provided in Appendix [B](https://arxiv.org/html/2510.06228v1#A2)), but physically distinct model of computation is depicted in Fig. [6](https://arxiv.org/html/2510.06228v1#S4.F6)(a), where a midcircuit measurement is performed on the first qubit. This model would be feasible for clients who can do fast midcircuit measurements, but existing midcircuit measurements are lengthy and error-prone (Deist et al., 2022; Rudinger et al., 2021).

Figure: Table 1: Unique requirements of different quantum models of Quorus, highlighting their usecases.

Solution 3: Funnel. Finally, for clients that may not have a high-shot budget, no ancillas, and no midcircuit measurement capability, we design a model that layer-by-layer drops operations that act on the first qubit, allowing all measurements to be at the end (Killoran et al., 2019). This model is depicted in Fig. [6](https://arxiv.org/html/2510.06228v1#S4.F6)(b), where we gradually “funnel” down the size of the deeper unitaries by dropping a qubit after each measurement, hence the name of this technique. The cost of this model is that the user must have a problem that is amenable to operating on fewer and fewer qubits.

Ansatz Use Case. We summarize the costs associated with each ansatz design in Table [1](https://arxiv.org/html/2510.06228v1#S4.T1) to highlight their unique usecases. Note that each model has disjoint requirements – that is, each model has exactly one cost, thus highlighting the versatility of our design choices to clients’ unique scenarios. We evaluate each design in Sec. [5](https://arxiv.org/html/2510.06228v1#S5) to compare their accuracy performance.

## 5 Experimental Evaluation

Here, we evaluate Quorus on different binary classification tasks. A comprehensive description of the experimental setup is in Appendix [C](https://arxiv.org/html/2510.06228v1#A3). We evaluate with 128 datapoints per client, consistent with existing QFL literature; to account for the random sampling of the data, we evaluate each of our comparisons with five different runs with five different samples of data allocations for clients.

**Table 2: Capacity-wise Comparison (V-Shape) — Baselines + Quorus-Layerwise with $\Delta$ to the Best (bolded). The means and standard deviations are shown for five different samples of data. We see that Quorus-Layerwise consistently outperforms the baselines across client capacities.**
| Capacity | Technique | MNIST | Fashion-MNIST |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | 0/1 | 3/4 | 4/9 | Trouser/Boot | Bag/Sandal | Pullover/Coat |
| 2L | Q-HeteroFL | $\,90.3\pm 5.2\,$ ($\downarrow 7.9$) | $\,58.8\pm 12.6\,$ ($\downarrow 37.3$) | $\,59.3\pm 7.3\,$ ($\downarrow 20.7$) | $\,62.4\pm 33.5\,$ ($\downarrow 36.4$) | $\,67.1\pm 14.6\,$ ($\downarrow 24.8$) | $\,58.9\pm 6.1\,$ ($\downarrow 18.0$) |
| Vanilla QFL (2L) | $\,98.2\pm 0.4\,$ ($\downarrow 0.0$) | $\,96.0\pm 1.2\,$ ($\downarrow 0.1$) | $\,80.0\pm 0.9\,$ | $\,98.5\pm 1.1\,$ ($\downarrow 0.3$) | $\,91.9\pm 1.2\,$ | $\,76.9\pm 0.4\,$ |  |
| Standalone | $\,98.2\pm 0.3\,$ | $\,96.1\pm 1.2\,$ | $\,78.5\pm 2.5\,$ ($\downarrow 1.5$) | $\,98.3\pm 0.9\,$ ($\downarrow 0.5$) | $\,91.2\pm 1.0\,$ ($\downarrow 0.7$) | $\,74.9\pm 1.8\,$ ($\downarrow 2.0$) |  |
| Quorus-Layerwise | $\,97.0\pm 1.4\,$ ($\downarrow 1.2$) | $\,95.0\pm 1.2\,$ ($\downarrow 1.1$) | $\,78.2\pm 0.6\,$ ($\downarrow 1.8$) | $\,98.8\pm 0.9\,$ | $\,86.1\pm 8.1\,$ ($\downarrow 5.8$) | $\,76.3\pm 1.4\,$ ($\downarrow 0.6$) |  |
| 3L | Q-HeteroFL | $\,79.6\pm 14.8\,$ ($\downarrow 18.7$) | $\,85.0\pm 3.8\,$ ($\downarrow 11.9$) | $\,68.5\pm 4.7\,$ ($\downarrow 11.9$) | $\,76.9\pm 15.0\,$ ($\downarrow 22.3$) | $\,79.1\pm 12.0\,$ ($\downarrow 13.0$) | $\,59.5\pm 10.5\,$ ($\downarrow 19.1$) |
| Vanilla QFL (2L) | $\,98.2\pm 0.4\,$ ($\downarrow 0.1$) | $\,96.0\pm 1.2\,$ ($\downarrow 0.9$) | $\,80.0\pm 0.9\,$ ($\downarrow 0.4$) | $\,98.5\pm 1.1\,$ ($\downarrow 0.7$) | $\,91.9\pm 1.2\,$ ($\downarrow 0.2$) | $\,76.9\pm 0.4\,$ ($\downarrow 1.7$) |  |
| Standalone | $\,98.3\pm 1.2\,$ | $\,95.5\pm 1.7\,$ ($\downarrow 1.4$) | $\,79.6\pm 3.4\,$ ($\downarrow 0.8$) | $\,99.1\pm 0.6\,$ ($\downarrow 0.1$) | $\,92.1\pm 2.4\,$ | $\,76.5\pm 2.5\,$ ($\downarrow 2.1$) |  |
| Quorus-Layerwise | $\,98.0\pm 1.0\,$ ($\downarrow 0.3$) | $\,96.9\pm 0.7\,$ | $\,80.4\pm 2.4\,$ | $\,99.2\pm 0.4\,$ | $\,89.2\pm 5.9\,$ ($\downarrow 2.9$) | $\,78.6\pm 1.0\,$ |  |
| 4L | Q-HeteroFL | $\,80.4\pm 7.6\,$ ($\downarrow 17.9$) | $\,88.0\pm 7.3\,$ ($\downarrow 9.5$) | $\,68.8\pm 5.0\,$ ($\downarrow 13.1$) | $\,90.5\pm 6.6\,$ ($\downarrow 8.8$) | $\,88.6\pm 2.0\,$ ($\downarrow 5.1$) | $\,72.8\pm 3.2\,$ ($\downarrow 5.9$) |
| Vanilla QFL (2L) | $\,98.2\pm 0.4\,$ ($\downarrow 0.1$) | $\,96.0\pm 1.2\,$ ($\downarrow 1.5$) | $\,80.0\pm 0.9\,$ ($\downarrow 1.9$) | $\,98.5\pm 1.1\,$ ($\downarrow 0.8$) | $\,91.9\pm 1.2\,$ ($\downarrow 1.8$) | $\,76.9\pm 0.4\,$ ($\downarrow 1.8$) |  |
| Standalone | $\,98.0\pm 2.5\,$ ($\downarrow 0.3$) | $\,97.4\pm 0.5\,$ ($\downarrow 0.1$) | $\,81.2\pm 3.7\,$ ($\downarrow 0.7$) | $\,98.9\pm 1.1\,$ ($\downarrow 0.4$) | $\,93.7\pm 1.1\,$ | $\,77.1\pm 1.0\,$ ($\downarrow 1.6$) |  |
| Quorus-Layerwise | $\,98.3\pm 0.9\,$ | $\,97.5\pm 0.6\,$ | $\,81.9\pm 2.2\,$ | $\,99.3\pm 0.3\,$ | $\,91.5\pm 4.0\,$ ($\downarrow 2.2$) | $\,78.7\pm 1.0\,$ |  |
| 5L | Q-HeteroFL | $\,89.9\pm 3.7\,$ ($\downarrow 8.6$) | $\,88.5\pm 5.3\,$ ($\downarrow 9.0$) | $\,71.0\pm 4.4\,$ ($\downarrow 11.5$) | $\,94.6\pm 4.3\,$ ($\downarrow 4.7$) | $\,88.4\pm 3.8\,$ ($\downarrow 5.9$) | $\,72.8\pm 1.2\,$ ($\downarrow 6.0$) |
| Vanilla QFL (2L) | $\,98.2\pm 0.4\,$ ($\downarrow 0.3$) | $\,96.0\pm 1.2\,$ ($\downarrow 1.5$) | $\,80.0\pm 0.9\,$ ($\downarrow 2.5$) | $\,98.5\pm 1.1\,$ ($\downarrow 0.8$) | $\,91.9\pm 1.2\,$ ($\downarrow 2.4$) | $\,76.9\pm 0.4\,$ ($\downarrow 1.9$) |  |
| Standalone | $\,97.2\pm 1.7\,$ ($\downarrow 1.3$) | $\,96.4\pm 1.9\,$ ($\downarrow 1.1$) | $\,80.3\pm 3.2\,$ ($\downarrow 2.2$) | $\,98.5\pm 0.5\,$ ($\downarrow 0.8$) | $\,94.3\pm 0.6\,$ | $\,77.6\pm 1.6\,$ ($\downarrow 1.2$) |  |
| Quorus-Layerwise | $\,98.5\pm 0.8\,$ | $\,97.5\pm 0.4\,$ | $\,82.5\pm 2.5\,$ | $\,99.3\pm 0.2\,$ | $\,92.4\pm 2.6\,$ ($\downarrow 1.9$) | $\,78.8\pm 1.1\,$ |  |
| 6L | Q-HeteroFL | $\,88.6\pm 6.2\,$ ($\downarrow 10.0$) | $\,85.1\pm 5.9\,$ ($\downarrow 12.7$) | $\,73.9\pm 4.4\,$ ($\downarrow 9.2$) | $\,95.3\pm 0.8\,$ ($\downarrow 4.1$) | $\,92.1\pm 1.3\,$ ($\downarrow 3.2$) | $\,74.4\pm 0.9\,$ ($\downarrow 4.4$) |
| Vanilla QFL (2L) | $\,98.2\pm 0.4\,$ ($\downarrow 0.4$) | $\,96.0\pm 1.2\,$ ($\downarrow 1.8$) | $\,80.0\pm 0.9\,$ ($\downarrow 3.1$) | $\,98.5\pm 1.1\,$ ($\downarrow 0.9$) | $\,91.9\pm 1.2\,$ ($\downarrow 3.4$) | $\,76.9\pm 0.4\,$ ($\downarrow 1.9$) |  |
| Standalone | $\,98.3\pm 1.0\,$ ($\downarrow 0.3$) | $\,96.5\pm 0.8\,$ ($\downarrow 1.3$) | $\,80.4\pm 3.4\,$ ($\downarrow 2.7$) | $\,98.3\pm 0.8\,$ ($\downarrow 1.1$) | $\,95.3\pm 1.0\,$ | $\,75.4\pm 1.5\,$ ($\downarrow 3.4$) |  |
| Quorus-Layerwise | $\,98.6\pm 0.8\,$ | $\,97.8\pm 0.2\,$ | $\,83.1\pm 2.4\,$ | $\,99.4\pm 0.3\,$ | $\,92.7\pm 2.5\,$ ($\downarrow 2.6$) | $\,78.8\pm 0.8\,$ |  |

Quorus outperforms state-of-the-art techniques in terms of classification accuracy. The state-of-the-art baselines that compare Quorus against are informed by what setups clients could run given that each has a different depth model, based on existing techniques described in Sec. [3](https://arxiv.org/html/2510.06228v1#S3). We compare against: (1) Q-HeteroFL, our quantum version of a classical technique called HeteroFL (Diao et al., 2021). Here, all clients run the maximum depth model they can, and the parameters are averaged only over the clients that contain those parameters. This work does not explicitly consider heterogeneous-model federated learning using PQC. Thus, our design of the quantum version of HeteroFL itself is novel and described in Appendix [C](https://arxiv.org/html/2510.06228v1#A3). (2) Vanilla QFL, where all clients use the same depth model as the shallowest-depth client. For clients that are able to run deeper models, they are unable to fully utilize their quantum resources. (3) Standalone, where clients do not participate in the FL process and train the data on their own. This approach has the clear disadvantage that clients do not get the benefit of training an improved model from other clients’ data.

We present our results in Table [2](https://arxiv.org/html/2510.06228v1#S5.T2), comparing the baselines above to Quorus-Layerwise, because it uses the same model architecture as the baselines. We present our results from the perspective of the client of different capacities in the leftmost “Capacity” column – for that capacity, what is the best performing technique for the various class comparisons? We see that, across client capacities, for most comparisons, Quorus-Layerwise has the highest mean testing accuracy ($12.4\%$ over Q-Hetero-FL). Notably, for clients of the smallest capacity, Quorus-Layerwise does not have the highest testing accuracy, but this is likely due to its modified loss function, which penalizes the first layer parameters, along with the loss values for clients with later layers. Another important observation is that Q-HeteroFL performs substantially worse compared to Quorus-Layerwise, sometimes nearly 40% worse, as in MNIST 3/4 classification. This is due to the parameter mismatching challenge: different, conflicting loss functions lead to suboptimal models. This highlights the importance of having a shared loss function between clients that can be optimized, which is what we present with Quorus-Layerwise.

**Table 3: Capacity-wise Comparison (V-Shape) — Quorus Variants Only with $\Delta$ to the Best (bolded). The means and standard deviations are calculated over five runs: Quorus-Layerwise and Quorus-Funnel have the highest testing accuracy (we use them for subsequent experiments).**
| Capacity | Technique | MNIST | Fashion-MNIST |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | 0/1 | 3/4 | 4/9 | Trouser/Boot | Bag/Sandal | Pullover/Coat |
| 2L | Quorus-Layerwise | $\,97.0\pm 1.4\,$ ($\downarrow 0.4$) | $\,95.0\pm 1.2\,$ ($\downarrow 0.3$) | $\,78.2\pm 0.6\,$ ($\downarrow 1.5$) | $\,98.8\pm 0.9\,$ | $\,86.1\pm 8.1\,$ ($\downarrow 0.3$) | $\,76.3\pm 1.4\,$ ($\downarrow 0.2$) |
| Quorus-Ancilla/Blocking | $\,97.0\pm 1.0\,$ ($\downarrow 0.4$) | $\,94.8\pm 1.5\,$ ($\downarrow 0.5$) | $\,78.3\pm 1.2\,$ ($\downarrow 1.4$) | $\,98.6\pm 0.9\,$ ($\downarrow 0.2$) | $\,86.2\pm 8.4\,$ ($\downarrow 0.2$) | $\,76.5\pm 1.3\,$ |  |
| Quorus-Funnel | $\,97.4\pm 1.2\,$ | $\,95.3\pm 1.5\,$ | $\,79.7\pm 2.0\,$ | $\,98.1\pm 1.1\,$ ($\downarrow 0.7$) | $\,86.4\pm 6.8\,$ | $\,76.4\pm 1.2\,$ ($\downarrow 0.1$) |  |
| 3L | Quorus-Layerwise | $\,98.0\pm 1.0\,$ ($\downarrow 0.1$) | $\,96.9\pm 0.7\,$ ($\downarrow 0.0$) | $\,80.4\pm 2.4\,$ ($\downarrow 1.9$) | $\,99.2\pm 0.4\,$ | $\,89.2\pm 5.9\,$ ($\downarrow 1.0$) | $\,78.6\pm 1.0\,$ ($\downarrow 0.1$) |
| Quorus-Ancilla/Blocking | $\,97.9\pm 1.2\,$ ($\downarrow 0.2$) | $\,96.9\pm 0.6\,$ | $\,81.4\pm 2.0\,$ ($\downarrow 0.9$) | $\,99.2\pm 0.5\,$ ($\downarrow 0.0$) | $\,88.7\pm 7.5\,$ ($\downarrow 1.5$) | $\,78.5\pm 1.2\,$ ($\downarrow 0.2$) |  |
| Quorus-Funnel | $\,98.1\pm 0.5\,$ | $\,96.9\pm 0.6\,$ ($\downarrow 0.0$) | $\,82.3\pm 1.8\,$ | $\,98.9\pm 0.6\,$ ($\downarrow 0.3$) | $\,90.2\pm 3.3\,$ | $\,78.7\pm 1.1\,$ |  |
| 4L | Quorus-Layerwise | $\,98.3\pm 0.9\,$ ($\downarrow 0.0$) | $\,97.5\pm 0.6\,$ | $\,81.9\pm 2.2\,$ ($\downarrow 1.3$) | $\,99.3\pm 0.3\,$ | $\,91.5\pm 4.0\,$ ($\downarrow 0.8$) | $\,78.7\pm 1.0\,$ ($\downarrow 0.7$) |
| Quorus-Ancilla/Blocking | $\,98.1\pm 1.2\,$ ($\downarrow 0.2$) | $\,97.3\pm 0.5\,$ ($\downarrow 0.2$) | $\,81.5\pm 1.9\,$ ($\downarrow 1.7$) | $\,99.2\pm 0.5\,$ ($\downarrow 0.1$) | $\,90.3\pm 5.5\,$ ($\downarrow 2.0$) | $\,78.9\pm 1.0\,$ ($\downarrow 0.5$) |  |
| Quorus-Funnel | $\,98.3\pm 0.7\,$ | $\,97.1\pm 0.6\,$ ($\downarrow 0.4$) | $\,83.2\pm 2.4\,$ | $\,99.0\pm 0.6\,$ ($\downarrow 0.3$) | $\,92.3\pm 1.7\,$ | $\,79.4\pm 1.0\,$ |  |
| 5L | Quorus-Layerwise | $\,98.5\pm 0.8\,$ ($\downarrow 0.0$) | $\,97.5\pm 0.4\,$ | $\,82.5\pm 2.5\,$ ($\downarrow 2.1$) | $\,99.3\pm 0.2\,$ | $\,92.4\pm 2.6\,$ ($\downarrow 0.3$) | $\,78.8\pm 1.1\,$ ($\downarrow 1.5$) |
| Quorus-Ancilla/Blocking | $\,98.3\pm 0.7\,$ ($\downarrow 0.2$) | $\,97.4\pm 0.5\,$ ($\downarrow 0.1$) | $\,81.9\pm 2.5\,$ ($\downarrow 2.7$) | $\,99.3\pm 0.3\,$ ($\downarrow 0.0$) | $\,91.1\pm 4.3\,$ ($\downarrow 1.6$) | $\,79.0\pm 1.4\,$ ($\downarrow 1.4$) |  |
| Quorus-Funnel | $\,98.5\pm 0.7\,$ | $\,97.1\pm 0.5\,$ ($\downarrow 0.4$) | $\,84.6\pm 2.1\,$ | $\,99.1\pm 0.4\,$ ($\downarrow 0.2$) | $\,92.7\pm 1.2\,$ | $\,80.4\pm 1.0\,$ |  |
| 6L | Quorus-Layerwise | $\,98.6\pm 0.8\,$ | $\,97.8\pm 0.2\,$ | $\,83.1\pm 2.4\,$ ($\downarrow 2.1$) | $\,99.4\pm 0.3\,$ | $\,92.7\pm 2.5\,$ ($\downarrow 0.7$) | $\,78.8\pm 0.8\,$ ($\downarrow 1.5$) |
| Quorus-Ancilla/Blocking | $\,98.4\pm 0.6\,$ ($\downarrow 0.2$) | $\,97.5\pm 0.5\,$ ($\downarrow 0.3$) | $\,82.2\pm 2.0\,$ ($\downarrow 3.0$) | $\,99.3\pm 0.3\,$ ($\downarrow 0.1$) | $\,91.4\pm 4.0\,$ ($\downarrow 2.0$) | $\,78.8\pm 1.1\,$ ($\downarrow 1.5$) |  |
| Quorus-Funnel | $\,98.0\pm 0.7\,$ ($\downarrow 0.6$) | $\,97.1\pm 0.4\,$ ($\downarrow 0.7$) | $\,85.2\pm 0.7\,$ | $\,99.1\pm 0.4\,$ ($\downarrow 0.3$) | $\,93.4\pm 0.9\,$ | $\,80.3\pm 0.9\,$ |  |

The performance of the different variants of Quorus. We now evaluate the performance of the variants of Quorus in Table [3](https://arxiv.org/html/2510.06228v1#S5.T3). Note that, because the Quorus-Ancilla and Quorus-Blocking designs are logically equivalent, their accuracies are displayed together. We see that Quorus-Layerwise and Quorus-Funnel have the best testing accuracy, although for many class comparisons, the difference between the techniques is within a single percentage point. This suggests that all of the Quorus have high testing accuracy, and that the decision of which model to use depends on the resource constraints of the client, as mentioned in Table [1](https://arxiv.org/html/2510.06228v1#S4.T1). In particular, for the Quorus-Funnel model, we observe that, even though later unitaries operate in a smaller Hilbert space, the testing accuracy is always within 1% of the best performing Quorus design, indicating its comparable accuracy. Importantly, the Quorus-Funnel model is also shot-efficient, and for the hardest classes (MNIST 4/9, Fashion-MNIST Pullover/Coat), it performs the best compared to the other models. Thus, we use the Quorus-Funnel model for subsequent noise analysis on real hardware evaluations.

## 6 Analysis of Quorus’s Functionality

Figure: Figure 7: We show the per-layer magnitude of the gradients for Quorus-Layerwise by plotting the mean and standard deviation of the gradient norms for each epoch (smoothed for readability). Compared to Q-HeteroFL, we see that our modified loss function has larger gradient norms throughout training for parameters earlier in the circuit, due to earlier measurements.
Refer to caption: x10.png

We split our analysis into two types: (1) gradient norms analysis and (2) analysis on real IBM superconducting hardware. Due to the extensive amount of runs required and the prohibitive cost of real-hardware runs, we only provide this analysis for the Pullover/Coat classification task from the Fashion-MNIST dataset as this is the most challenging task.

Higher Gradient Norms with Quorus. Typically, the deeper the circuit, the smaller the magnitudes of the gradients become (Cerezo et al., 2021). We verify this empirically in our setup as well, plotting the gradient norms of Quorus-Layerwise and Q-HeteroFL in Fig. [7](https://arxiv.org/html/2510.06228v1#S6.F7). We see that for the Q-HeteroFL model, the gradient norms are small for each layer in the quantum circuit, as the loss for all parameters is defined on the output measurement at the end of the circuit. Interestingly, for Quorus, this is not the case. Because we have loss functions that are defined after each layer, for deep models, earlier layers maintain a high gradient norm due to these layerwise loss functions. Note that for parameters in later layers, the gradient norms remain small because the gradients for these parameters only depend on measurements deep in the circuit. However, the overall magnitudes of the gradients for Quorus are higher, and in addition, Quorus also obtains a higher testing accuracy than Q-HeteroFL, making it implausible that the reasons for the larger gradient norms are due to a lack of convergence for Quorus. This result suggests how the layerwise loss function in Quorus can be used for improved and scalable trainability for deep quantum circuits.

Figure: (a)
Refer to caption: x11.png

Evaluation of Quorus on Real Quantum Hardware. We evaluate our trained models on all of IBM’s superconducting quantum processing units or QPUs to demonstrate the practical relevance of our experimental setup, as well as the very real impact that noise has on our trained models. In particular, we perform our hardware analysis using the Quorus-Funnel design, because it allows for single-shot evaluation of ensembled models. Due to the high error of midcircuit measurements on current hardware, we measure all qubits at the end (Rudinger et al., 2021; Gao et al., 2025). The depth of the Quorus-Funnel models therefore matters, as for deeper models, more decoherence will accumulate on the qubits that are unused or carry information from earlier layers.

(A) Same Model, Different QPUs. We evaluate Quorus with a depth of 5 on different IBM QPUs to validate the heterogeneity of quantum systems. We restricted our testing set to only 100 datapoints due to the prohibitive cost of each shot. Our results in Fig. [8](https://arxiv.org/html/2510.06228v1#S6.F8)(a) show that across six different QPUs, the noise varies substantially: from 48% for IBM Brisbane to 76% for IBM Torino, 3% off from the ideal simulation accuracy. If a client has access to a machine with similar hardware noise characteristics to IBM Torino, they should go with a deep circuit. Thus, we observe a diverse spectrum of error on IBM’s QPUs, validating the practical relevance of our experimental setup.

(B) Different Depth Model, Same QPU. In Fig. [8](https://arxiv.org/html/2510.06228v1#S6.F8)(a), we notice that the QPU with the lowest testing accuracy (aside from IBM Brisbane, which suffered from decoherence to 48% testing accuracy with just two layers of our model) is IBM Kingston. Thus, we performed an analysis on IBM Kingston to verify the impact of decreasing the depth of the quantum circuit on the testing accuracy; we expect that as we reduce the number of layers, the testing accuracy should increase. Our hypothesis is empirically validated in Fig. [8](https://arxiv.org/html/2510.06228v1#S6.F8)(b). We see that the separation, indicated by a dashed red line, between the ideal simulation results and the testing accuracy on IBM Kingston gets wider with a deeper circuit. This highlights that, for a client with access to a computer similar to IBM Kingston in terms of hardware noise, it is advantageous for them to train a shallow-depth quantum classifier, because these classifiers have lower-error outputs and can more meaningfully contribute to FL.

## 7 Conclusion

In this work, we introduced Quorus, a QFL framework tailored for heterogeneous-depth clients. Our contributions include: (1) a layerwise loss with high gradient norms to align objectives across clients of varying circuit depths, (2) multiple circuit designs, Layerwise, Ancilla/Blocking, and Funnel, that balance accuracy with resource constraints, and (3) extensive evaluation showing up to 12.4% accuracy improvements over Q-HeteroFL and consistently higher gradient magnitudes for deeper clients. Crucially, we validated Quorus on all of IBM’s superconducting quantum processors, demonstrating that our method is not only effective in simulation but also practical on today’s error-prone hardware. Together, these results establish Quorus as the first implementable framework for QFL in realistic multi-client settings, paving the way for scalable and resource-aware QML.

## 8 Acknowledgement

This work was supported by Rice University, the Rice University George R. Brown School of Engineering and Computing, and the Rice University Department of Computer Science. This work was supported by the DOE Quantum Testbed Finder Award DE-SC0024301, the Ken Kennedy Institute, and Rice Quantum Initiative, which is part of the Smalley-Curl Institute. We acknowledge the use of IBM Quantum services for this work. The views expressed are those of the authors, and do not reflect the official policy or position of IBM or the IBM Quantum team.

## References

- (1)
IBM Quantum Computing — IBM Quantum Computing — Products and services — ibm.com.
[https://www.ibm.com/quantum/products#compare-features](https://www.ibm.com/quantum/products#compare-features).
[Accessed 24-09-2025].
- Acharya et al. (2024)
Rajeev Acharya, Dmitry A. Abanin, Laleh Aghababaie-Beni, Igor Aleiner, Trond I. Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Nikita Astrakhantsev, Juan Atalaya, Ryan Babbush, Dave Bacon, Brian Ballard, Joseph C. Bardin, Johannes Bausch, Andreas Bengtsson, Alexander Bilmes, Sam Blackwell, Sergio Boixo, Gina Bortoli, Alexandre Bourassa, Jenna Bovaird, Leon Brill, Michael Broughton, David A. Browne, Brett Buchea, Bob B. Buckley, David A. Buell, Tim Burger, Brian Burkett, Nicholas Bushnell, Anthony Cabrera, Juan Campero, Hung-Shen Chang, Yu Chen, Zijun Chen, Ben Chiaro, Desmond Chik, Charina Chou, Jahan Claes, Agnetta Y. Cleland, Josh Cogan, Roberto Collins, Paul Conner, William Courtney, Alexander L. Crook, Ben Curtin, Sayan Das, Alex Davies, Laura De Lorenzo, Dripto M. Debroy, Sean Demura, Michel Devoret, Agustin Di Paolo, Paul Donohoe, Ilya Drozdov, Andrew Dunsworth, Clint Earle, Thomas Edlich, Alec Eickbusch, Aviv Moshe Elbag, Mahmoud Elzouka, Catherine Erickson, Lara Faoro, Edward Farhi,
Vinicius S. Ferreira, Leslie Flores Burgos, Ebrahim Forati, Austin G. Fowler, Brooks Foxen, Suhas Ganjam, Gonzalo Garcia, Robert Gasca, Élie Genois, William Giang, Craig Gidney, Dar Gilboa, Raja Gosula, Alejandro Grajales Dau, Dietrich Graumann, Alex Greene, Jonathan A. Gross, Steve Habegger, John Hall, Michael C. Hamilton, Monica Hansen, Matthew P. Harrigan, Sean D. Harrington, Francisco J. H. Heras, Stephen Heslin, Paula Heu, Oscar Higgott, Gordon Hill, Jeremy Hilton, George Holland, Sabrina Hong, Hsin-Yuan Huang, Ashley Huff, William J. Huggins, Lev B. Ioffe, Sergei V. Isakov, Justin Iveland, Evan Jeffrey, Zhang Jiang, Cody Jones, Stephen Jordan, Chaitali Joshi, Pavol Juhas, Dvir Kafri, Hui Kang, Amir H. Karamlou, Kostyantyn Kechedzhi, Julian Kelly, Trupti Khaire, Tanuj Khattar, Mostafa Khezri, Seon Kim, Paul V. Klimov, Andrey R. Klots, Bryce Kobrin, Pushmeet Kohli, Alexander N. Korotkov, Fedor Kostritsa, Robin Kothari, Borislav Kozlovskii, John Mark Kreikebaum, Vladislav D. Kurilovich, Nathan Lacroix,
David Landhuis, Tiano Lange-Dei, Brandon W. Langley, Pavel Laptev, Kim-Ming Lau, Loïck Le Guevel, Justin Ledford, Joonho Lee, Kenny Lee, Yuri D. Lensky, Shannon Leon, Brian J. Lester, Wing Yan Li, Yin Li, Alexander T. Lill, Wayne Liu, William P. Livingston, Aditya Locharla, Erik Lucero, Daniel Lundahl, Aaron Lunt, Sid Madhuk, Fionn D. Malone, Ashley Maloney, Salvatore Mandrà, James Manyika, Leigh S. Martin, Orion Martin, Steven Martin, Cameron Maxfield, Jarrod R. McClean, Matt McEwen, Seneca Meeks, Anthony Megrant, Xiao Mi, Kevin C. Miao, Amanda Mieszala, Reza Molavi, Sebastian Molina, Shirin Montazeri, Alexis Morvan, Ramis Movassagh, Wojciech Mruczkiewicz, Ofer Naaman, Matthew Neeley, Charles Neill, Ani Nersisyan, Hartmut Neven, Michael Newman, Jiun How Ng, Anthony Nguyen, Murray Nguyen, Chia-Hung Ni, Murphy Yuezhen Niu, Thomas E. O’Brien, William D. Oliver, Alex Opremcak, Kristoffer Ottosson, Andre Petukhov, Alex Pizzuto, John Platt, Rebecca Potter, Orion Pritchard, Leonid P. Pryadko, Chris Quintana,
Ganesh Ramachandran, Matthew J. Reagor, John Redding, David M. Rhodes, Gabrielle Roberts, Eliott Rosenberg, Emma Rosenfeld, Pedram Roushan, Nicholas C. Rubin, Negar Saei, Daniel Sank, Kannan Sankaragomathi, Kevin J. Satzinger, Henry F. Schurkus, Christopher Schuster, Andrew W. Senior, Michael J. Shearn, Aaron Shorter, Noah Shutty, Vladimir Shvarts, Shraddha Singh, Volodymyr Sivak, Jindra Skruzny, Spencer Small, Vadim Smelyanskiy, W. Clarke Smith, Rolando D. Somma, Sofia Springer, George Sterling, Doug Strain, Jordan Suchard, Aaron Szasz, Alex Sztein, Douglas Thor, Alfredo Torres, M. Mert Torunbalci, Abeer Vaishnav, Justin Vargas, Sergey Vdovichev, Guifre Vidal, Benjamin Villalonga, Catherine Vollgraff Heidweiller, Steven Waltman, Shannon X. Wang, Brayden Ware, Kate Weber, Travis Weidel, Theodore White, Kristi Wong, Bryan W. K. Woo, Cheng Xing, Z. Jamie Yao, Ping Yeh, Bicheng Ying, Juhwan Yoo, Noureldin Yosri, Grayson Young, Adam Zalcman, Yaxing Zhang, Ningfeng Zhu, and Nicholas Zobrist.
Quantum error correction below the surface code threshold.
*Nature*, 638(8052):920–926, December 2024.
ISSN 1476-4687.
doi: 10.1038/s41586-024-08449-y.
URL [http://dx.doi.org/10.1038/s41586-024-08449-y](http://dx.doi.org/10.1038/s41586-024-08449-y).
- Aminpour et al. (2024)
S. Aminpour, Y. Banad, and S. Sharif.
Strategic data re-uploads: A pathway to improved quantum classification data re-uploading strategies for improved quantum classifier performance, 2024.
URL [https://arxiv.org/abs/2405.09377](https://arxiv.org/abs/2405.09377).
- Anschuetz (2025)
Eric Anschuetz.
A unified theory of quantum neural network loss landscapes.
In Y. Yue, A. Garg, N. Peng, F. Sha, and R. Yu (eds.), *International Conference on Representation Learning*, volume 2025, pp. 97859–97918, 2025.
URL [https://proceedings.iclr.cc/paper_files/paper/2025/file/f3680ca31afcb9076846950dbc72c7e3-Paper-Conference.pdf](https://proceedings.iclr.cc/paper_files/paper/2025/file/f3680ca31afcb9076846950dbc72c7e3-Paper-Conference.pdf).
- Bergholm et al. (2022)
Ville Bergholm, Josh Izaac, Maria Schuld, Christian Gogolin, Shahnawaz Ahmed, Vishnu Ajith, M. Sohaib Alam, Guillermo Alonso-Linaje, B. AkashNarayanan, Ali Asadi, Juan Miguel Arrazola, Utkarsh Azad, Sam Banning, Carsten Blank, Thomas R Bromley, Benjamin A. Cordier, Jack Ceroni, Alain Delgado, Olivia Di Matteo, Amintor Dusko, Tanya Garg, Diego Guala, Anthony Hayes, Ryan Hill, Aroosa Ijaz, Theodor Isacsson, David Ittah, Soran Jahangiri, Prateek Jain, Edward Jiang, Ankit Khandelwal, Korbinian Kottmann, Robert A. Lang, Christina Lee, Thomas Loke, Angus Lowe, Keri McKiernan, Johannes Jakob Meyer, J. A. Montañez-Barrera, Romain Moyard, Zeyue Niu, Lee James O’Riordan, Steven Oud, Ashish Panigrahi, Chae-Yeun Park, Daniel Polatajko, Nicolás Quesada, Chase Roberts, Nahum Sá, Isidor Schoch, Borun Shi, Shuli Shu, Sukin Sim, Arshpreet Singh, Ingrid Strandberg, Jay Soni, Antal Száva, Slimane Thabet, Rodrigo A. Vargas-Hernández, Trevor Vincent, Nicola Vitucci, Maurice Weber, David Wierichs, Roeland Wiersema, Moritz
Willmann, Vincent Wong, Shaoming Zhang, and Nathan Killoran.
Pennylane: Automatic differentiation of hybrid quantum-classical computations, 2022.
URL [https://arxiv.org/abs/1811.04968](https://arxiv.org/abs/1811.04968).
- Calderbank & Shor (1996)
A. R. Calderbank and Peter W. Shor.
Good quantum error-correcting codes exist.
*Physical Review A*, 54(2):1098–1105, August 1996.
ISSN 1094-1622.
doi: 10.1103/physreva.54.1098.
URL [http://dx.doi.org/10.1103/PhysRevA.54.1098](http://dx.doi.org/10.1103/PhysRevA.54.1098).
- Cerezo et al. (2021)
M. Cerezo, Akira Sone, Tyler Volkoff, Lukasz Cincio, and Patrick J. Coles.
Cost function dependent barren plateaus in shallow parametrized quantum circuits.
*Nature Communications*, 12(1), March 2021.
ISSN 2041-1723.
doi: 10.1038/s41467-021-21728-w.
URL [http://dx.doi.org/10.1038/s41467-021-21728-w](http://dx.doi.org/10.1038/s41467-021-21728-w).
- Chen & Yoo (2021)
Samuel Yen-Chi Chen and Shinjae Yoo.
Federated quantum machine learning.
*Entropy*, 23(4):460, 2021.
- Deist et al. (2022)
Emma Deist, Yue-Hui Lu, Jacquelyn Ho, Mary Kate Pasha, Johannes Zeiher, Zhenjie Yan, and Dan M. Stamper-Kurn.
Mid-circuit cavity measurement in a neutral atom array.
*Phys. Rev. Lett.*, 129:203602, Nov 2022.
doi: 10.1103/PhysRevLett.129.203602.
URL [https://link.aps.org/doi/10.1103/PhysRevLett.129.203602](https://link.aps.org/doi/10.1103/PhysRevLett.129.203602).
- Diao et al. (2021)
Enmao Diao, Jie Ding, and Vahid Tarokh.
Heterofl: Computation and communication efficient federated learning for heterogeneous clients, 2021.
URL [https://arxiv.org/abs/2010.01264](https://arxiv.org/abs/2010.01264).
- DiBrita et al. (2025)
Nicholas S. DiBrita, Jason Han, and Tirthak Patel.
Resq: A novel framework to implement residual neural networks on analog rydberg atom quantum computers, 2025.
URL [https://arxiv.org/abs/2506.21537](https://arxiv.org/abs/2506.21537).
- Gao et al. (2025)
Yang Gao, Feiyu Li, Yang Liu, Zhen Yang, Jiayu Ding, Wuerkaixi Nuerbolati, Ruixia Wang, Tang Su, Yanjun Ma, Yirong Jin, Haifeng Yu, He Wang, and Fei Yan.
Mitigating measurement crosstalk via pulse shaping, 2025.
URL [https://arxiv.org/abs/2509.05437](https://arxiv.org/abs/2509.05437).
- Gidney & Ekerå (2021)
Craig Gidney and Martin Ekerå.
How to factor 2048 bit rsa integers in 8 hours using 20 million noisy qubits.
*Quantum*, 5:433, April 2021.
ISSN 2521-327X.
doi: 10.22331/q-2021-04-15-433.
URL [http://dx.doi.org/10.22331/q-2021-04-15-433](http://dx.doi.org/10.22331/q-2021-04-15-433).
- Grammenos et al. (2020)
Andreas Grammenos, Rodrigo Mendoza Smith, Jon Crowcroft, and Cecilia Mascolo.
Federated principal component analysis.
In H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin (eds.), *Advances in Neural Information Processing Systems*, volume 33, pp. 6453–6464. Curran Associates, Inc., 2020.
URL [https://proceedings.neurips.cc/paper_files/paper/2020/file/47a658229eb2368a99f1d032c8848542-Paper.pdf](https://proceedings.neurips.cc/paper_files/paper/2020/file/47a658229eb2368a99f1d032c8848542-Paper.pdf).
- Gurevich & Blass (2021)
Yuri Gurevich and Andreas Blass.
Quantum circuits with classical channels and the principle of deferred measurements, 2021.
URL [https://arxiv.org/abs/2107.08324](https://arxiv.org/abs/2107.08324).
- Gyawali et al. (2024)
Gaurav Gyawali, Sonny Rappaport, Tiago Sereno, and Michael J. Lawler.
Measurement-induced landscape transitions and coding barren plateaus in hybrid variational quantum circuits, 2024.
URL [https://arxiv.org/abs/2312.09135](https://arxiv.org/abs/2312.09135).
- Han et al. (2025)
Jason Han, Nicholas S. DiBrita, Younghyun Cho, Hengrui Luo, and Tirthak Patel.
EnQode: Fast Amplitude Embedding for Quantum Machine Learning Using Classical Data.
In *2025 62nd ACM/IEEE Design Automation Conference (DAC)*, pp. 1–8. IEEE, 2025.
- Holmes et al. (2022)
Zoë Holmes, Kunal Sharma, M. Cerezo, and Patrick J. Coles.
Connecting ansatz expressibility to gradient magnitudes and barren plateaus.
*PRX Quantum*, 3(1), January 2022.
ISSN 2691-3399.
doi: 10.1103/prxquantum.3.010313.
URL [http://dx.doi.org/10.1103/PRXQuantum.3.010313](http://dx.doi.org/10.1103/PRXQuantum.3.010313).
- Huo et al. (2025)
Yuqian Huo, Jinbiao Wei, Christopher Kverne, Mayur Akewar, Janki Bhimani, and Tirthak Patel.
Revisiting noise-adaptive transpilation in quantum computing: How much impact does it have?
*IEEE/ACM International Conference on Computer-Aided Design (ICCAD)*, 2025.
- Ilhan et al. (2023)
Fatih Ilhan, Gong Su, and Ling Liu.
Scalefl: Resource-adaptive federated learning with heterogeneous clients.
In *2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)*, pp. 24532–24541, 2023.
doi: 10.1109/CVPR52729.2023.02350.
- Javadi-Abhari et al. (2024)
Ali Javadi-Abhari, Matthew Treinish, Kevin Krsulich, Christopher J. Wood, Jake Lishman, Julien Gacon, Simon Martiel, Paul D. Nation, Lev S. Bishop, Andrew W. Cross, Blake R. Johnson, and Jay M. Gambetta.
Quantum computing with qiskit, 2024.
URL [https://arxiv.org/abs/2405.08810](https://arxiv.org/abs/2405.08810).
- Kashif et al. (2025)
Muhammad Kashif, Alberto Marchisio, and Muhammad Shafique.
Computational advantage in hybrid quantum neural networks: Myth or reality?
In *2025 62nd ACM/IEEE Design Automation Conference (DAC)*, pp. 1–7, 2025.
doi: 10.1109/DAC63849.2025.11132906.
- Killoran et al. (2019)
Nathan Killoran, Thomas R. Bromley, Juan Miguel Arrazola, Maria Schuld, Nicolás Quesada, and Seth Lloyd.
Continuous-variable quantum neural networks.
*Phys. Rev. Res.*, 1:033063, Oct 2019.
doi: 10.1103/PhysRevResearch.1.033063.
URL [https://link.aps.org/doi/10.1103/PhysRevResearch.1.033063](https://link.aps.org/doi/10.1103/PhysRevResearch.1.033063).
- Kim et al. (2023)
Minjae Kim, Sangyoon Yu, Suhyun Kim, and Soo-Mook Moon.
DepthFL : Depthwise federated learning for heterogeneous clients.
In *The Eleventh International Conference on Learning Representations*, 2023.
URL [https://openreview.net/forum?id=pf8RIZTMU58](https://openreview.net/forum?id=pf8RIZTMU58).
- Kivlichan et al. (2018)
Ian D. Kivlichan, Jarrod McClean, Nathan Wiebe, Craig Gidney, Alán Aspuru-Guzik, Garnet Kin-Lic Chan, and Ryan Babbush.
Quantum simulation of electronic structure with linear depth and connectivity.
*Physical Review Letters*, 120(11), March 2018.
ISSN 1079-7114.
doi: 10.1103/physrevlett.120.110501.
URL [http://dx.doi.org/10.1103/PhysRevLett.120.110501](http://dx.doi.org/10.1103/PhysRevLett.120.110501).
- Lee et al. (2024)
Royson Lee, Javier Fernandez-Marques, Shell Xu Hu, Da Li, Stefanos Laskaridis, Łukasz Dudziak, Timothy Hospedales, Ferenc Huszár, and Nicholas D. Lane.
Recurrent early exits for federated learning with heterogeneous clients.
In *Proceedings of the 41st International Conference on Machine Learning*, ICML’24. JMLR.org, 2024.
- Leither et al. (2025)
Sydney Leither, Michael Kubal, and Sonika Johri.
How many qubits does a machine learning problem require?
*arXiv preprint arXiv:2508.20992*, 2025.
- Liu et al. (2025)
Chen-Yu Liu, Kuan-Cheng Chen, Yi-Chien Chen, Samuel Yen-Chi Chen, Wei-Hao Huang, Wei-Jia Huang, and Yen-Jui Chang.
Quantum-enhanced parameter-efficient learning for typhoon trajectory forecasting, 2025.
URL [https://arxiv.org/abs/2505.09395](https://arxiv.org/abs/2505.09395).
- McClean et al. (2016)
Jarrod R McClean, Jonathan Romero, Ryan Babbush, and Alán Aspuru-Guzik.
The theory of variational hybrid quantum-classical algorithms.
*New Journal of Physics*, 18(2):023023, February 2016.
ISSN 1367-2630.
doi: 10.1088/1367-2630/18/2/023023.
URL [http://dx.doi.org/10.1088/1367-2630/18/2/023023](http://dx.doi.org/10.1088/1367-2630/18/2/023023).
- McMahan et al. (2023)
H. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Agüera y Arcas.
Communication-efficient learning of deep networks from decentralized data, 2023.
URL [https://arxiv.org/abs/1602.05629](https://arxiv.org/abs/1602.05629).
- Montanez-Barrera et al. (2025)
J. A. Montanez-Barrera, Kristel Michielsen, and David E. Bernal Neira.
Evaluating the performance of quantum processing units at large width and depth, 2025.
URL [https://arxiv.org/abs/2502.06471](https://arxiv.org/abs/2502.06471).
- Nguyen et al. (2022)
Tuyen Nguyen, Incheon Paik, Yutaka Watanobe, and Truong Cong Thang.
An evaluation of hardware-efficient quantum neural networks for image data classification.
*Electronics*, 11(3), 2022.
ISSN 2079-9292.
doi: 10.3390/electronics11030437.
URL [https://www.mdpi.com/2079-9292/11/3/437](https://www.mdpi.com/2079-9292/11/3/437).
- Patel et al. (2024)
Yash J. Patel, Akash Kundu, Mateusz Ostaszewski, Xavier Bonet-Monroig, Vedran Dunjko, and Onur Danaci.
Curriculum reinforcement learning for quantum architecture search under hardware errors.
In *The Twelfth International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=rINBD8jPoP](https://openreview.net/forum?id=rINBD8jPoP).
- Peral-García et al. (2024)
David Peral-García, Juan Cruz-Benito, and Francisco José García-Peñalvo.
Systematic literature review: Quantum machine learning and its applications.
*Computer Science Review*, 51:100619, 2024.
ISSN 1574-0137.
doi: https://doi.org/10.1016/j.cosrev.2024.100619.
URL [https://www.sciencedirect.com/science/article/pii/S1574013724000030](https://www.sciencedirect.com/science/article/pii/S1574013724000030).
- Preskill (2018)
John Preskill.
Quantum computing in the nisq era and beyond.
*Quantum*, 2:79, August 2018.
ISSN 2521-327X.
doi: 10.22331/q-2018-08-06-79.
URL [http://dx.doi.org/10.22331/q-2018-08-06-79](http://dx.doi.org/10.22331/q-2018-08-06-79).
- Rahman et al. (2025)
Ratun Rahman, Atit Pokharel, and Dinh C. Nguyen.
Sporadic federated learning approach in quantum environment to tackle quantum noise, 2025.
URL [https://arxiv.org/abs/2507.12492](https://arxiv.org/abs/2507.12492).
- Ranjan et al. (2024)
Aditya Ranjan, Tirthak Patel, Daniel Silver, Harshitta Gandhi, and Devesh Tiwari.
Proximl: Building machine learning classifiers for photonic quantum computing.
In *Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3*, ASPLOS ’24, pp. 834–849, New York, NY, USA, 2024. Association for Computing Machinery.
ISBN 9798400703867.
doi: 10.1145/3620666.3651367.
URL [https://doi.org/10.1145/3620666.3651367](https://doi.org/10.1145/3620666.3651367).
- Romero et al. (2018)
Jonathan Romero, Ryan Babbush, Jarrod R. McClean, Cornelius Hempel, Peter Love, and Alán Aspuru-Guzik.
Strategies for quantum computing molecular energies using the unitary coupled cluster ansatz, 2018.
URL [https://arxiv.org/abs/1701.02691](https://arxiv.org/abs/1701.02691).
- Rudinger et al. (2021)
Kenneth Rudinger, Guilhem J. Ribeill, Luke C. G. Govia, Matthew Ware, Erik Nielsen, Kevin Young, Thomas A. Ohki, Robin Blume-Kohout, and Timothy Proctor.
Characterizing mid-circuit measurements on a superconducting qubit using gate set tomography, 2021.
URL [https://arxiv.org/abs/2103.03008](https://arxiv.org/abs/2103.03008).
- Sahu & Gupta (2024)
Himanshu Sahu and Hari Prabhat Gupta.
Nac-qfl: Noise aware clustered quantum federated learning, 2024.
URL [https://arxiv.org/abs/2406.14236](https://arxiv.org/abs/2406.14236).
- Schlosshauer (2019)
Maximilian Schlosshauer.
Quantum decoherence.
*Physics Reports*, 831:1–57, 2019.
ISSN 0370-1573.
doi: https://doi.org/10.1016/j.physrep.2019.10.001.
URL [https://www.sciencedirect.com/science/article/pii/S0370157319303084](https://www.sciencedirect.com/science/article/pii/S0370157319303084).
Quantum decoherence.
- Schuld et al. (2020)
Maria Schuld, Alex Bocharov, Krysta M. Svore, and Nathan Wiebe.
Circuit-centric quantum classifiers.
*Physical Review A*, 101(3), March 2020.
ISSN 2469-9934.
doi: 10.1103/physreva.101.032308.
URL [http://dx.doi.org/10.1103/PhysRevA.101.032308](http://dx.doi.org/10.1103/PhysRevA.101.032308).
- Sevilla & Riedel (2020)
Jaime Sevilla and C. Jess Riedel.
Forecasting timelines of quantum computing, 2020.
URL [https://arxiv.org/abs/2009.05045](https://arxiv.org/abs/2009.05045).
- Sim et al. (2019)
Sukin Sim, Peter D. Johnson, and Alán Aspuru‐Guzik.
Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.
*Advanced Quantum Technologies*, 2(12), October 2019.
ISSN 2511-9044.
doi: 10.1002/qute.201900070.
URL [http://dx.doi.org/10.1002/qute.201900070](http://dx.doi.org/10.1002/qute.201900070).
- Smaldone et al. (2025)
Anthony M. Smaldone, Yu Shee, Gregory W. Kyro, Chuzhi Xu, Nam P. Vu, Rishab Dutta, Marwa H. Farag, Alexey Galda, Sandeep Kumar, Elica Kyoseva, and Victor S. Batista.
Quantum machine learning in drug discovery: Applications in academia and pharmaceutical industries.
*Chemical Reviews*, 125(12):5436–5460, 2025.
doi: 10.1021/acs.chemrev.4c00678.
URL [https://doi.org/10.1021/acs.chemrev.4c00678](https://doi.org/10.1021/acs.chemrev.4c00678).
PMID: 40479601.
- Sugisaki et al. (2022)
Kenji Sugisaki, Takumi Kato, Yuichiro Minato, Koji Okuwaki, and Yuji Mochizuki.
Variational quantum eigensolver simulations with the multireference unitary coupled cluster ansatz: a case study of the C2v quasi-reaction pathway of beryllium insertion into a H2 molecule.
*Physical Chemistry Chemical Physics*, 24(14):8439–8452, April 2022.
doi: 10.1039/D1CP04318H.
URL [https://doi.org/10.1039/D1CP04318H](https://doi.org/10.1039/D1CP04318H).
- Sá et al. (2023)
Nahum Sá, Ivan S. Oliveira, and Itzhak Roditi.
Towards solving the bcs hamiltonian gap in near-term quantum computers.
*Results in Physics*, 44:106131, January 2023.
ISSN 2211-3797.
doi: 10.1016/j.rinp.2022.106131.
URL [http://dx.doi.org/10.1016/j.rinp.2022.106131](http://dx.doi.org/10.1016/j.rinp.2022.106131).
- Tannu & Qureshi (2019)
Swamit S. Tannu and Moinuddin K. Qureshi.
Not all qubits are created equal: A case for variability-aware policies for nisq-era quantum computers.
In *Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems*, ASPLOS ’19, pp. 987–999, New York, NY, USA, 2019. Association for Computing Machinery.
ISBN 9781450362405.
doi: 10.1145/3297858.3304007.
URL [https://doi.org/10.1145/3297858.3304007](https://doi.org/10.1145/3297858.3304007).
- Vidal & Theis (2020)
Javier Gil Vidal and Dirk Oliver Theis.
Input redundancy for parameterized quantum circuits, 2020.
URL [https://arxiv.org/abs/1901.11434](https://arxiv.org/abs/1901.11434).
- Wang et al. (2021)
Jianyu Wang, Zheng Xu, Zachary Garrett, Zachary Charles, Luyang Liu, and Gauri Joshi.
Local adaptivity in federated learning: Convergence and consistency, 2021.
URL [https://arxiv.org/abs/2106.02305](https://arxiv.org/abs/2106.02305).
- Yan et al. (2024)
Ge Yan, Hongxu Chen, Kaisen Pan, and Junchi Yan.
Rethinking the symmetry-preserving circuits for constrained variational quantum algorithms.
In *The Twelfth International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=SL7djdVpde](https://openreview.net/forum?id=SL7djdVpde).
- Yun et al. (2022)
Won Joon Yun, Jae Pyoung Kim, Hankyul Baek, Soyi Jung, Jihong Park, Mehdi Bennis, and Joongheon Kim.
Quantum federated learning with entanglement controlled circuits and superposition coding, 2022.
URL [https://arxiv.org/abs/2212.01732](https://arxiv.org/abs/2212.01732).
- Zhang et al. (2025)
Kai Zhang, Yutong Dai, Hongyi Wang, Eric Xing, Xun Chen, and Lichao Sun.
Memory-adaptive depth-wise heterogeneous federated learning, 2025.
URL [https://arxiv.org/abs/2303.04887](https://arxiv.org/abs/2303.04887).
- Zurek (2003)
Wojciech Hubert Zurek.
Decoherence, einselection, and the quantum origins of the classical.
*Rev. Mod. Phys.*, 75:715–775, May 2003.
doi: 10.1103/RevModPhys.75.715.
URL [https://link.aps.org/doi/10.1103/RevModPhys.75.715](https://link.aps.org/doi/10.1103/RevModPhys.75.715).

## Appendix A Further Preliminaries

Figure: Figure 9: Visualization of rotation gates on a quantum Bloch sphere.
Refer to caption: x13.png

Quantum Gates. Quantum gates are unitary operators that manipulate qubits in a quantum circuit, analogous to logic gates in classical circuits. The rotation gates apply continuous rotations of a qubit’s state on the Bloch sphere (Fig. [9](https://arxiv.org/html/2510.06228v1#A1.F9)). For example, the $R_{y}(\theta)$ gate performs a rotation around the $y$-axis by angle $\theta$:

$$ $R_{y}(\theta)\;=\;\begin{bmatrix}\cos\!\left(\tfrac{\theta}{2}\right)&-\sin\!\left(\tfrac{\theta}{2}\right)\[6.0pt] \sin\!\left(\tfrac{\theta}{2}\right)&\cos\!\left(\tfrac{\theta}{2}\right)\end{bmatrix}.$ $$

More generally, the three-axis rotation operator $Rot(\alpha,\beta,\gamma)$ applies successive rotations about the $x$, $y$, and $z$ axes by angles $\alpha$, $\beta$, and $\gamma$:

$$ $Rot(\alpha,\beta,\gamma)\;=\;R_{z}(\gamma)\,R_{y}(\beta)\,R_{z}(\alpha),$ $$

where

$$ $R_{z}(\phi)=\begin{bmatrix}e^{-i\phi/2}&0\[6.0pt] 0&e^{i\phi/2}\end{bmatrix}.$ $$

Entangling gates act on two or more qubits. A key example is the controlled-NOT (CNOT) gate, which flips the target qubit if the control qubit is in state $\ket{1}$. Its $4\times 4$ unitary matrix is:

$$ $\mathrm{CNOT}\;=\;\begin{bmatrix}1&0&0&0\\ 0&1&0&0\\ 0&0&0&1\\ 0&0&1&0\end{bmatrix}.$ $$

The gate representation in a circuit diagram has the target qubit and the control qubit connected with a vertical line, with the control qubit indicated by a filled-in circle and the target qubit indicated by the $\oplus$ symbol. Together, single-qubit rotation gates and entangling gates like CNOT form a universal gate set, capable of approximating any quantum operation.

## Appendix B Proof that the Quorus-Ancilla Circuit is Equivalent to the Quorus-Blocking Circuit

In this section, we prove that the circuits in Fig. [5](https://arxiv.org/html/2510.06228v1#S4.F5) and Fig. [6](https://arxiv.org/html/2510.06228v1#S4.F6)(a), namely, the Ancilla technique and the blocking technique, are equivalent. To do so, we will consider the state of both circuits immediately after the measurement operation.

We first note that both circuits apply the same unitary $U\ket{0}^{\otimes n}=\ket{\psi}$. We note that the same logic applies for subsequent layers (replacing $\ket{\psi}$ with the resulting input state will suffice), so analyzing this single-layer setup is sufficient.

Additionally, we assume that, in the Ancilla circuit, the ancilla qubit is immediately measured after the CNOT gate. This simplifies the analysis and is equivalent to the case where the ancilla is measured later, as no other operations are performed on the ancilla qubit, so we apply the deferred measurement principle (Gurevich & Blass, 2021).

###### Proposition 1 (Ancilla–measurement equals measuring the control) .

Let $U$ be an $n$-qubit unitary and let $\ket{\psi}=U\ket{0}^{\otimes n}$.
Write $\ket{\psi}$ as

$$ $\ket{\psi}=\alpha\,\ket{0}\ket{\phi_{0}}+\beta\,\ket{1}\ket{\phi_{1}},$ $$

where the first ket is qubit 0, $\ket{\phi_{b}}$ are normalized states of the remaining $n-1$ qubits, and
$|\alpha|^{2}+|\beta|^{2}=1$.
Consider two procedures:

*(A) Direct measurement.*
Measure qubit 0 in the computational ($Z$) basis.
The probabilities are
$p_{b}=\|\big(\ket{b}\!\bra{b}\otimes I\big)\ket{\psi}\|^{2}=|\alpha|^{2}\text{ for }b=0$
and
$|\beta|^{2}\text{ for }b=1,$
and the post-measurement (normalized) states of the remaining qubits are $\ket{\phi_{b}}$.

*(B) Ancilla measurement.*
Prepare an ancilla $a$ in $\ket{0}_{a}$, apply a CNOT with control qubit $1$ and target $a$, then
measure $a$ in the computational $Z$ basis.
After the CNOT, the joint state is

$$ $\alpha\,\ket{0}\ket{0}_{a}\ket{\phi_{0}}+\beta\,\ket{1}\ket{1}_{a}\ket{\phi_{1}}.$ $$

Projecting onto $\ket{b}_{a}$ yields outcome $b$ with probability
$p^{\prime}_{b}=\|\alpha\,\ket{0}\ket{\phi_{0}}\|^{2}\text{ for }b=0$
and
$\|\beta\,\ket{1}\ket{\phi_{1}}\|^{2}\text{ for }b=1,$
i.e. $p^{\prime}_{0}=|\alpha|^{2}$ and $p^{\prime}_{1}=|\beta|^{2}$.
Conditioned on outcome $b$, the (normalized) post-measurement state of the system qubits is
$\ket{b}\ket{\phi_{b}}$; tracing out qubit $1$ leaves the remaining qubits in $\ket{\phi_{b}}$.

Thus, $p_{b}=p^{\prime}_{b}$ and the conditional post-measurement states of the non-ancilla qubits coincide in
(A) and (B). Consequently, for any subsequent (classically controlled) processing, the two procedures
are operationally equivalent.
∎

###### Proposition 1 (Ancilla–measurement equals measuring the control) .

## Appendix C Details of Our Experimental Methodology

**Table 4: Experimental details, specification, and hyperparameters used to evaluate Quorus.**
| \rowcolorcyan!10Parameter | Value |
| --- | --- |
| Dataset | MNIST; Fashion-MNIST |
| Classes | 0/1, 3/4, 4/9 for MNIST; Trouser/Boot, Bag/Sandal, Pullover/Coat for Fashion-MNIST |
| Number of clients $K$ | 5 |
| Datapoints per Client | 128 |
| Testing set size | 3000; 100 for hardware runs only |
| Data Distribution | IID |
| Number of different data splits per class comparison | 5 |
| Data encoding scheme | Angle Embedding |
| Client sampling per round | 100% |
| Communication rounds $T$ | 1000 |
| Local epochs per round $E$ | 1 |
| Batch size | 32 |
| Optimizer | Adam ($\beta_{1}{=}$0.9, $\beta_{2}{=}$0.99) |
| Learning rate $\eta$ | 0.001 |
| LR schedule | 1.0 (No decay) |
| Loss type | Binary Cross Entropy on Labels |
|  | KL Divergence between logits |
| Aggregation Method | Circular averaging of subnet parameters |
| Qubits $q$ | 10 |
| Depth levels $L$ | 2L, 3L, 4L, 5L, 6L (1 Client per Depth level) |
| Parameters per layer | 30 |
| Parameter Initialization | $\mathcal{N}(0,1)$ |
| Shot Count | For training, none (analytic); for IBM Hardware evaluations, 1000 |

We present the experimental details and hyperparameters in Table [4](https://arxiv.org/html/2510.06228v1#A3.T4). For all experiments, the five runs used across different technique types have the same training data split between clients, testing data, and initial parameters to isolate the effect of the techniques themselves. Because image data is high-dimensional and amplitude encoding is not feasible on near-term devices due to the high depth (Han et al., 2025), we perform angle encoding. This means that we must compress the image into a set of 10 features, and we do so using PCA. One might ask the question of how to perform PCA on decentralized data. This problem has been solved using a technique called Federated PCA (Grammenos et al., 2020), which provides the same PCA results as centralized PCA. Because the implementation details of Federated PCA are not central to Quorus, we emulate Federated PCA with centralized PCA in our implementation and note that the PCA implementation can be substituted as desired.

For inference on testing data, the testing data is compressed using the PCA fit on the training data. We assume the use of Federated PCA for all of our experiments, even for Standalone training, for both consistency and for considering the “adversarial” case where a client decides to participate in Federated PCA to obtain better reduced features, but chooses not to participate in the FL process. In addition, to consider the most adversarial setup for Standalone training, where a client does not participate in the FL process, the optimizer state for Adam persists across rounds (whereas, in our QFL setups, we reset the Adam optimizer state each round, as done in  Wang et al. (2021)). We evaluate on the specific classes in MNIST and Fashion-MNIST as they represent various levels of difficulty, used in other QML works (DiBrita et al., 2025; Ranjan et al., 2024). For implementation of Quorus, we utilize Pennylane and Qiskit (Bergholm et al., 2022; Javadi-Abhari et al., 2024).

The hardware specifications of the IBM QPUs are provided in Table [5](https://arxiv.org/html/2510.06228v1#A3.T5).

### C.1 Q-HeteroFL Framework

Figure: Algorithm 2 Q-HeteroFL

We describe the Q-HeteroFL technique in Algorithm [2](https://arxiv.org/html/2510.06228v1#alg2), an adaptation of the aggregation technique for heterogeneous classical FL described in Diao et al. (2021). The loss function is defined solely on the deepest classifier output, and aggregation is also done using circular averaging for consistency in comparison to Quorus. HeteroFL is the standard baseline in heterogeneous FL but has not yet been proposed in QFL; thus, we propose it here and demonstrate Quorus’s improvements over it.

**Table 5: IBM QPUs and their performance characteristics. 2Q refers to the two-qubit gate error, which is typically specified, as it is an order of magnitude more dominant than the 1Q gate error.**
| \rowcolormagenta!10QPU name | Qubits | 2Q error (best) | 2Q error (layered) | CLOPS | Processor type |
| --- | --- | --- | --- | --- | --- |
| Pittsburgh | 156 | 8.11E-4 | 3.81E-3 | 250K | Heron r3 |
| Kingston | 156 | 7.82E-4 | 3.57E-3 | 250K | Heron r2 |
| Fez | 156 | 1.45E-3 | 4.28E-3 | 195K | Heron r2 |
| Marrakesh | 156 | 1.11E-3 | 3.72E-3 | 195K | Heron r2 |
| Torino | 133 | 1.29E-3 | 7.50E-3 | 210K | Heron r1 |
| Brisbane | 127 | 2.87E-3 | 1.74E-2 | 180K | Eagle r3 |

## Appendix D Additional Results and Analysis

**Table 6: Best Ansatz by Client Capacity for Ensembled Submodels, Quorus. The table is sectioned off into different capacities based on the number of layers a client can run. The best-performing ansatz for each different class comparison is in bold. The V-shaped ansatz has the highest testing accuracy the most times, so we use it for all of our experiments.**
| Capacity | Ansatz | MNIST | Fashion-MNIST |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | 0/1 | 3/4 | 4/9 | Trouser/Boot | Bag/Sandal | Pullover/Coat |
| 2L | Staircase | $97.9\pm 1.1$ | $95.2\pm 1.9$ | $73.5\pm 5.3$ ($\downarrow 4.7$) | $97.5\pm 2.1$ ($\downarrow 1.3$) | $93.4\pm 0.9$ | $66.9\pm 1.7$ ($\downarrow 9.4$) |
| V-shape | $97.0\pm 1.4$ ($\downarrow 0.9$) | $95.0\pm 1.2$ ($\downarrow 0.2$) | $78.2\pm 0.6$ | $98.8\pm 0.9$ | $86.1\pm 8.1$ ($\downarrow 7.3$) | $76.3\pm 1.4$ |  |
| Alternating | $88.2\pm 6.6$ ($\downarrow 9.7$) | $84.5\pm 17.6$ ($\downarrow 10.7$) | $65.5\pm 5.8$ ($\downarrow 12.7$) | $82.0\pm 19.8$ ($\downarrow 16.8$) | $82.7\pm 16.3$ ($\downarrow 10.7$) | $66.8\pm 4.9$ ($\downarrow 9.5$) |  |
| 3L | Staircase | $98.2\pm 1.0$ | $96.2\pm 0.8$ ($\downarrow 0.7$) | $81.0\pm 2.8$ | $98.6\pm 0.8$ ($\downarrow 0.6$) | $93.7\pm 0.8$ | $74.1\pm 3.0$ ($\downarrow 4.5$) |
| V-shape | $98.0\pm 1.0$ ($\downarrow 0.2$) | $96.9\pm 0.7$ | $80.4\pm 2.4$ ($\downarrow 0.6$) | $99.2\pm 0.4$ | $89.2\pm 5.9$ ($\downarrow 4.5$) | $78.6\pm 1.0$ |  |
| Alternating | $92.0\pm 4.0$ ($\downarrow 6.2$) | $94.8\pm 1.2$ ($\downarrow 2.1$) | $79.9\pm 1.6$ ($\downarrow 1.1$) | $97.1\pm 0.7$ ($\downarrow 2.1$) | $91.7\pm 0.9$ ($\downarrow 2.0$) | $73.5\pm 3.4$ ($\downarrow 5.1$) |  |
| 4L | Staircase | $98.2\pm 0.6$ ($\downarrow 0.1$) | $96.4\pm 0.7$ ($\downarrow 1.1$) | $82.0\pm 2.3$ | $98.7\pm 0.9$ ($\downarrow 0.6$) | $93.7\pm 0.9$ | $73.8\pm 2.4$ ($\downarrow 4.9$) |
| V-shape | $98.3\pm 0.9$ | $97.5\pm 0.6$ | $81.9\pm 2.2$ ($\downarrow 0.1$) | $99.3\pm 0.3$ | $91.5\pm 4.0$ ($\downarrow 2.2$) | $78.7\pm 1.0$ |  |
| Alternating | $93.8\pm 2.0$ ($\downarrow 4.5$) | $95.2\pm 1.1$ ($\downarrow 2.3$) | $81.8\pm 3.0$ ($\downarrow 0.2$) | $97.6\pm 0.5$ ($\downarrow 1.7$) | $92.5\pm 1.3$ ($\downarrow 1.2$) | $74.8\pm 2.3$ ($\downarrow 3.9$) |  |
| 5L | Staircase | $98.1\pm 0.6$ ($\downarrow 0.4$) | $96.3\pm 0.4$ ($\downarrow 1.2$) | $83.0\pm 2.6$ | $98.8\pm 0.7$ ($\downarrow 0.5$) | $93.7\pm 0.8$ | $74.2\pm 2.2$ ($\downarrow 4.6$) |
| V-shape | $98.5\pm 0.8$ | $97.5\pm 0.4$ | $82.5\pm 2.5$ ($\downarrow 0.5$) | $99.3\pm 0.2$ | $92.4\pm 2.6$ ($\downarrow 1.3$) | $78.8\pm 1.1$ |  |
| Alternating | $93.8\pm 2.0$ ($\downarrow 4.7$) | $95.6\pm 1.1$ ($\downarrow 1.9$) | $82.1\pm 2.9$ ($\downarrow 0.9$) | $97.6\pm 0.7$ ($\downarrow 1.7$) | $92.5\pm 1.2$ ($\downarrow 1.2$) | $75.3\pm 2.0$ ($\downarrow 3.5$) |  |
| 6L | Staircase | $98.0\pm 0.8$ ($\downarrow 0.6$) | $96.3\pm 0.7$ ($\downarrow 1.5$) | $83.1\pm 3.2$ ($\downarrow 0.0$) | $98.8\pm 0.8$ ($\downarrow 0.6$) | $93.8\pm 0.9$ | $74.6\pm 1.9$ ($\downarrow 4.2$) |
| V-shape | $98.6\pm 0.8$ | $97.8\pm 0.2$ | $83.1\pm 2.4$ | $99.4\pm 0.3$ | $92.7\pm 2.5$ ($\downarrow 1.1$) | $78.8\pm 0.8$ |  |
| Alternating | $93.1\pm 2.7$ ($\downarrow 5.5$) | $95.3\pm 1.1$ ($\downarrow 2.5$) | $82.4\pm 2.7$ ($\downarrow 0.7$) | $97.4\pm 0.7$ ($\downarrow 2.0$) | $92.6\pm 1.1$ ($\downarrow 1.2$) | $75.3\pm 1.9$ ($\downarrow 3.5$) |  |

### D.1 Ansatz Choice Analysis

We perform a comprehensive analysis of what ansatz to use in our experiments for Quorus-Layerwise by evaluating the Staircase, V-shape, and an Alternating variant of the former two across MNIST and Fashion-MNIST classes. Note that, for $L$ layers in our Quorus-Layerwise, we have $L-1$ different classifiers (one classifier per layer, with the first layer having two variational layers). This means that, for a client that can run a capacity of $L$ layers, they can ensemble the outputs of their $L-1$ classifiers for inference. That is what is shown in Table [6](https://arxiv.org/html/2510.06228v1#A4.T6) and is how Quorus is evaluated in the tables in the main text. We see that, across a majority of the capacities and class comparisons, the V-shape ansatz has the highest testing accuracy, making it the better choice on average. A reason for this is that the V-shape has the largest number of CNOT gates and circuit depth compared to the Staircase and Alternating ansatzes, and thus it may be more expressive. From the results in this table, we decide to use the V-shape ansatz as the default in our experiments.

### D.2 Ablation on the Number of Layers

To justify the layer count we used in our experiments, we evaluate Quorus-Layerwise using both fewer and more layers, depicted in Table [7](https://arxiv.org/html/2510.06228v1#A4.T7). We run two additional ablations: Quorus with the five clients having 1, 2, 3, 4, and 5 layers respectively; and Quorus with the five clients having 2, 4, 6, 8, and 10 layers, respectively (note that the case where the 5 clients have 2, 3, 4, 5, and 6 layers, respectively is what is used by default in our work).

Figure: Figure 10: Testing accuracies of the subclassifiers and submodels of a single Quorus - Funnel model evaluated on IBM Kingston. We see that ensembling outputs yields higher accuracy, similar to what we see in ideal simulation.
Refer to caption: x14.png

We would like to point out that using 1 layer appears to have drastically lower testing accuracy, at times 40% lower than 6 or 10 layers. This suggests that clients with 1 layer do not have enough parameters to contribute well to the training, a result consistent with intuition. There is also a question of whether we use more layers and whether it is helpful for clients. We see that, for our setup, using more layers (up to 8 or 10 layers) has marginal gains in testing accuracy. This result is consistent with quantum computing literature, where adding more layers to solve a problem saturates in gains beyond a certain point (Nguyen et al., 2022). Thus, we use 2 through 6 layers in our experimental setup, as more layers lead to higher testing accuracy in this regime, as well as for the fact that quantum circuits of this size are amenable to running on real-world hardware, as we show in our analysis section.

### D.3 Robustness of Quorus Amidst Real Hardware Noise

In comparing the performance of various depth circuits used in Quorus-Funnel on real hardware, we observe an interesting result. In Fig. [10](https://arxiv.org/html/2510.06228v1#A4.F10), we plot the testing accuracy on 100 datapoints for one model trained on Fashion-MNIST Pullover/Coat classification, evaluated on IBM Kingston. We run our depth 5 model on IBM Kingston, meaning that in total, we extract 5 classifier outputs (one output for each layer) in a single shot on IBM Kingston. We plot the accuracies of the classifiers of each layer, plotted in red dots, as well as the accuracies of the classifier ensemble up to that layer, plotted in yellow dots. We similarly plot the classifier accuracies from each layer in ideal simulation in dark blue dots, and the ensemble of the classifiers up to that layer in light blue.

One interesting observation is in the separation between the individual classifier and ensemble outputs in ideal and hardware evaluation. Notably, on IBM Kingston, although the testing accuracy is below 60% for individual classifiers for depth 3 and later, the ensemble of these classifiers generally increases, and maintains a nearly 20% separation at layer 5. This suggests that even though noise can corrupt individual classifier outputs, Quorus is robust to hardware errors from its in-built single-shot ensemble evaluation and is able to substantially mitigate these hardware errors.

**Table 7: Capacity-wise Comparison (V-Shape) — Quorus-Layerwise sizes with $\Delta$ to the Best. Means $\pm$ standard deviation shown over five splits; mean ties broken on standard deviation.**
| Capacity | Quorus Layer Count | MNIST | Fashion-MNIST |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  |  | 0/1 | 3/4 | 4/9 | Trouser/Boot | Bag/Sandal | Pullover/Coat |
| 1 | Quorus-Layerwise (1L) | $\,59.5\pm 1.2\,$ ($\downarrow 37.5$) | $\,63.8\pm 2.7\,$ ($\downarrow 31.2$) | $\,67.1\pm 5.0\,$ ($\downarrow 11.9$) | $\,58.6\pm 2.9\,$ ($\downarrow 40.2$) | $\,59.7\pm 4.5\,$ ($\downarrow 28.9$) | $\,66.9\pm 1.2\,$ ($\downarrow 9.4$) |
| Quorus-Layerwise (2L) | $\,97.0\pm 1.4\,$ | $\,95.0\pm 1.2\,$ ($\downarrow 0.0$) | $\,78.2\pm 0.6\,$ ($\downarrow 0.8$) | $\,98.8\pm 0.9\,$ | $\,86.1\pm 8.1\,$ ($\downarrow 2.5$) | $\,76.3\pm 1.4\,$ |  |
| Quorus-Layerwise (2L) | $\,95.0\pm 3.8\,$ ($\downarrow 2.0$) | $\,95.0\pm 2.3\,$ | $\,79.0\pm 2.7\,$ | $\,97.1\pm 2.3\,$ ($\downarrow 1.7$) | $\,88.6\pm 1.7\,$ | $\,75.3\pm 1.7\,$ ($\downarrow 1.0$) |  |
| 2 | Quorus-Layerwise (2L) | $\,96.4\pm 1.9\,$ ($\downarrow 1.6$) | $\,95.1\pm 1.9\,$ ($\downarrow 1.8$) | $\,77.7\pm 5.0\,$ ($\downarrow 4.9$) | $\,97.3\pm 1.5\,$ ($\downarrow 1.9$) | $\,88.0\pm 4.7\,$ ($\downarrow 4.1$) | $\,75.3\pm 2.0\,$ ($\downarrow 3.3$) |
| Quorus-Layerwise (3L) | $\,98.0\pm 1.0\,$ | $\,96.9\pm 0.7\,$ | $\,80.4\pm 2.4\,$ ($\downarrow 2.2$) | $\,99.2\pm 0.4\,$ | $\,89.2\pm 5.9\,$ ($\downarrow 2.9$) | $\,78.6\pm 1.0\,$ |  |
| Quorus-Layerwise (4L) | $\,97.5\pm 1.3\,$ ($\downarrow 0.5$) | $\,96.7\pm 1.0\,$ ($\downarrow 0.2$) | $\,82.6\pm 2.1\,$ | $\,98.6\pm 0.7\,$ ($\downarrow 0.6$) | $\,92.1\pm 0.7\,$ | $\,77.6\pm 1.3\,$ ($\downarrow 1.0$) |  |
| 3 | Quorus-Layerwise (3L) | $\,97.5\pm 1.4\,$ ($\downarrow 0.8$) | $\,96.6\pm 1.1\,$ ($\downarrow 0.9$) | $\,80.0\pm 4.0\,$ ($\downarrow 3.0$) | $\,97.9\pm 1.0\,$ ($\downarrow 1.4$) | $\,91.9\pm 2.3\,$ ($\downarrow 1.2$) | $\,77.1\pm 1.6\,$ ($\downarrow 1.6$) |
| Quorus-Layerwise (4L) | $\,98.3\pm 0.9\,$ | $\,97.5\pm 0.6\,$ | $\,81.9\pm 2.2\,$ ($\downarrow 1.1$) | $\,99.3\pm 0.3\,$ | $\,91.5\pm 4.0\,$ ($\downarrow 1.6$) | $\,78.7\pm 1.0\,$ |  |
| Quorus-Layerwise (6L) | $\,97.5\pm 1.1\,$ ($\downarrow 0.8$) | $\,97.0\pm 0.6\,$ ($\downarrow 0.5$) | $\,83.0\pm 2.3\,$ | $\,98.8\pm 1.0\,$ ($\downarrow 0.5$) | $\,93.1\pm 0.5\,$ | $\,78.3\pm 1.6\,$ ($\downarrow 0.4$) |  |
| 4 | Quorus-Layerwise (4L) | $\,98.5\pm 0.7\,$ ($\downarrow 0.0$) | $\,97.0\pm 1.0\,$ ($\downarrow 0.5$) | $\,81.4\pm 3.8\,$ ($\downarrow 2.3$) | $\,98.9\pm 0.5\,$ ($\downarrow 0.4$) | $\,92.8\pm 1.8\,$ ($\downarrow 0.8$) | $\,77.8\pm 1.2\,$ ($\downarrow 1.0$) |
| Quorus-Layerwise (5L) | $\,98.5\pm 0.8\,$ | $\,97.5\pm 0.4\,$ | $\,82.5\pm 2.5\,$ ($\downarrow 1.2$) | $\,99.3\pm 0.2\,$ | $\,92.4\pm 2.6\,$ ($\downarrow 1.2$) | $\,78.8\pm 1.1\,$ |  |
| Quorus-Layerwise (8L) | $\,97.5\pm 0.9\,$ ($\downarrow 1.0$) | $\,97.0\pm 0.7\,$ ($\downarrow 0.5$) | $\,83.7\pm 2.3\,$ | $\,98.8\pm 0.9\,$ ($\downarrow 0.5$) | $\,93.6\pm 0.5\,$ | $\,78.3\pm 1.4\,$ ($\downarrow 0.5$) |  |
| 5 | Quorus-Layerwise (5L) | $\,98.3\pm 0.9\,$ ($\downarrow 0.3$) | $\,97.3\pm 0.8\,$ ($\downarrow 0.5$) | $\,81.7\pm 4.4\,$ ($\downarrow 2.2$) | $\,98.8\pm 0.3\,$ ($\downarrow 0.6$) | $\,92.9\pm 1.8\,$ ($\downarrow 0.9$) | $\,77.7\pm 1.0\,$ ($\downarrow 1.1$) |
| Quorus-Layerwise (6L) | $\,98.6\pm 0.8\,$ | $\,97.8\pm 0.2\,$ | $\,83.1\pm 2.4\,$ ($\downarrow 0.8$) | $\,99.4\pm 0.3\,$ | $\,92.7\pm 2.5\,$ ($\downarrow 1.1$) | $\,78.8\pm 0.8\,$ |  |
| Quorus-Layerwise (10L) | $\,97.5\pm 0.8\,$ ($\downarrow 1.1$) | $\,97.0\pm 0.6\,$ ($\downarrow 0.8$) | $\,83.9\pm 2.2\,$ | $\,98.8\pm 0.8\,$ ($\downarrow 0.6$) | $\,93.8\pm 0.5\,$ | $\,78.1\pm 1.5\,$ ($\downarrow 0.7$) |  |

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: - How does your algorithm scale with the number of layers and number of agents? It would be useful to provide scalability experiments.
- Can you handle heterogeneous datasets? Can you run experiments with such settings?
- How do you justify such a complex design for a very small (around 10%) gain?
- What type of quantum hardware is needed for this solution to work?
- Can you study the effect of error correction or mitigation?
soundness: 3
strengths: + The idea of using varying-depth quantum circuits is both interesting and timely.
+ The authors provide extensive experiments to validate their approach.
+ The solution can reduce barren plateau effects.
+ There are clear relevance to emerging quantum platforms.
summary: This paper proposes a quantum federated learning algorithm that can account for errors in quantum circuits. The authors use extensive simulations to show how this approach can improve test accuracy.
weaknesses: - The gains from the experiments seem very limited.
- The scalability of this solution is not studied.
- The results seem limited to basic classification tasks.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. How does your Layerwise Federated Learning (LFL) framework differ conceptually and algorithmically from prior “layerwise parameter sharing” or “selective aggregation” methods?

2. Have you compared with or at least cited existing selective-layer FL methods in the classical setting (e.g., FedPer, FedRep, Selective-FedAvg, FedDrop, FedPAQ)? If not, please justify why those are not directly comparable or include a baseline comparison.

3. Could your algorithm be interpreted as a special case of layer-dropout or structured sparsification techniques? If so, why does it deserve to be treated as a new paradigm rather than an instance of that family?
soundness: 3
strengths: 1. The work firstly proposes the Quorus framework that is tailored for heterogeneous-depth clients, providing an alternative way to realize quantum machine learning on realistic quantum processors without QEC techniques. 

2. The proposed layer-importance metric based on normalized gradient variance and the communication schedule can be plugged into existing federated learning systems, demonstrating the advantages of Quorus in this work. 

3. The experiments are scalable to 50-200 clients, making the authors' claimed methods reasonable. 

4. The appendix includes detailed hyperparameters, dataset information, and pseudo code.
summary: In this work, the authors propose a structured Federated Learning framework (Quorus) that adaptively selects and synchronizes subsets of model layers within the framework of federated learning optimization. Instead of transmitting the complete parameter set or using uniform layer selection, LFL introduces a layer-wise importance estimator and communication scheduler that determines which layers to aggregate in each round based on gradient variance and update magnitude. 

The experiments on binary classification on the MNIST and Fashion MNIST datasets demonstrate that the proposed approaches consistently outperform other quantum federated learning methods, such as Q-HeteroFL, and achieve better performance on IBM quantum platforms.
weaknesses: 1. Although the work claims to propose that the Quorus is effective in both simulation and realistic quantum processors, the approach is largely heuristic. In particular, the gradient-variance-based importance metric is intuitive, and it does not involve convergence or bias-variance analysis of partial aggregation. 

2. The work exacerbates the fairness gaps across clients if some layers are seldom updated. It looks like the authors mention this in passing, but do not quantify or mitigate it. 

3. The paper omits comparison with communication-efficient Federated Learning methods such as FedDrop, Sparse Ternary Compression, or Selective-FedAvg, which are conceptually closest. 

4. Ablations on importance metric choices or thresholds are limited. It is unclear how sensitive the system is to hyperparameters (e.g., top-k fraction per round).

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 3
questions: 1. How does the proposed KL coupling affect the optimization landscape for deeper clients? Can the authors provide a theoretical or empirical justification that this does not restrict the expressive power of deeper PQCs?

2. Do the authors expect the claimed gains to hold on multiclass or quantum-native datasets? It would be very interesting to see.
soundness: 2
strengths: The problem formulation and framing are clear, focusing on depth heterogeneity in QFL. The concrete FL procedure with circular angle averaging, parameter slicing by depth, and layerwise loss is an impressive methodology.

Circuit engineering is thoughtful. The designs cover orthogonal resource constraints such as shots, ancillae, and mid-circuit measurement, and they are practical on current hardware. The Funnel variant is particularly pragmatic. 

Validation on real quantum hardware is a core strength.
summary: The paper presents a federated learning framework to train quantum clients with different circuit depths by applying a layerwise loss (pairwise KL coupling and circular aggregation of rotation parameters). The authors claim up to a 12.4 percent accuracy gain over “Q-HeteroFL” on binary classification of MNIST and Fashion-MNIST datasets. The manuscript also presents results across multiple IBM QPUs.
weaknesses: Major Weaknesses: 
The evaluation scope is narrow. Only binary classification is used, and only on MNIST and Fashion-MNIST (both grayscale, 28×28 toy image datasets). No multiclass tasks, no quantum-native datasets, and missing diversity (especially in a paper that lacks theoretical proofs) weaken the authors’ claims. These datasets are fairly simple and do not require deep quantum circuits to perform well. Under this narrow experimental setting, a 12 percent improvement over a baseline does not establish general scalability, robustness, or utility of the method.

When a paper offers only empirical support, it is expected to include evaluation across multiple types of problems, including at least multiclass classification and a different dataset, such as CIFAR-10 or CIFAR-100. None are present.

Because the experiments are so limited in difficulty and diversity, the work must instead offer compensation with solid theoretical justification that proves why the method should work beyond toy datasets. However, convergence theory is missing, there is no stationary-point guarantee, and no rigorous mathematical explanation of how KL coupling affects the optimization landscape.

Minor (for maximum information transfer) Issues: 
The data encoding pipeline is under-specified. Feature preprocessing, feature-to-quantum-state mapping, and the reupload schedule (mentioned briefly in the paper) are extremely important. These affect the number of qubits required as well as circuit depth. Upon checking the appendix and supplementary materials, I found that the authors used PCA to reduce the dimensionality. Overall, reproducibility and completeness of the paper are negatively impacted by the lack of inclusion of these details in the main manuscript. I hope the authors include this.

Baseline selection seems to inflate the claimed gains. Vanilla QFL forces all clients to use the shallowest model, giving predictably weak results. Standalone training is a trivial lower bound. Q-HeteroFL is an extension of HeteroFL, implemented by the authors without external validation. It is not clear whether these baselines are suitable enough to be regarded as “state of the art.”
On the one hand, the engineering around layerwise circuit execution is very creative, and the hardware study is a solid strength. I would love to score this paper very highly if theoretical guarantees were provided or if the experiments were significantly more diverse.

---

confidence: 4
contribution: 3
initial_rating: 2
presentation: 2
questions: 1. In line 265, "Passing the state unchanged thus requires you to prepare another copy of it, which induces additional shot overhead that is linear in the number of layers and is a nontrivial cost" → does this mean state tomography is required in general? And how is this linear in the number of layers? 
2. Following W2, how does the ansatz enable the single-shot behavior? Is there any proof? From line 296, "we evaluate each layer's outputs by computing the marginal distribution on its ancilla" → how can you calculate the "distribution" with a single shot?
3. Does the parameter aggregation process, which aligns parameters for models with different layers, affect the expressiveness? For example, a quantum state produces output, becoming an intermediate state of another model. And this "another model," after additional layers, will produce the output of the same task. Then why not just use the shallower model if a shallow circuit is enough for such a task?
soundness: 3
strengths: 1. Using layerwise losses for QFL is a novel approach. 
2. The paper is well-written overall.
summary: The authors propose a method to address the problem of different architectures and behaviors of quantum computers in a quantum federated learning scheme. They use layerwise loss to aggregate the parameters of local QNNs with specific approaches, gaining performance improvements. The proposed method is examined on real quantum computers.
weaknesses: 1. The proposed method appears limited to binary classification problems. 
2. Line 291 states "we design an ansatz where it is possible to obtain the outputs from all layers in a single shot," but it's unclear how the ansatz enables single-shot behavior.
3. The baselines compared are only QML models, no classical baseline is included. It is plausible that classical models could easily outperform QML models on binary classification problems.


Decision: Accept (Poster)