Quorus: Quantum Federated & Distributed Frameworks

• The paper on quantum federated learning shows Quorus’s layerwise training boosts testing accuracy by 12.4% over state-of-the-art baselines.
• In distributed all-pairs computation, Quorus uses cyclic quorum sets to reduce data replication by up to 67% and achieve a 7× speedup on multi-node systems.
• Quorus also connects with broader quorum theory, clarifying distinctions from similarly named platforms like Quorum and Quoracle in storage and consensus applications.

Searching arXiv for papers relevant to “Quorus” and closely related quorum-system usages. arXiv search query: "Quorus" Quorus denotes distinct but conceptually related constructs in recent technical literature. In its most specific and recent usage, it is a quantum federated learning framework for heterogeneous quantum clients, designed for settings in which participants have different tolerances for circuit depth, noise, qubit count, and measurement capability (Han et al., 30 Sep 2025). In another usage, it is a quorum-based framework for scaling distributed all-pairs computations while reducing data replication (Kleinheksel et al., 2016). The term also invites confusion with the broader theory of quorum systems—a collection of subsets of replicas, called quorums, such that any two quorums intersect—and with adjacent systems such as Quoracle, GeoQuorum, and Quorum (Whittaker et al., 2021, Luo et al., 2011, Baliga et al., 2018).

1. Terminological scope and disambiguation

In the arXiv literature surveyed here, “Quorus” is not a single universally fixed name. It appears as a proper name in quantum federated learning and in distributed all-pairs computation, and it is also used informally as a near-match for several quorum-based constructions.

Usage	Domain	Brief characterization
Quorus (Han et al., 30 Sep 2025)	Quantum federated learning	Layerwise federated learning for heterogeneous quantum clients
Quorus (Kleinheksel et al., 2016)	Distributed all-pairs computation	Cyclic quorum sets for all-pairs coverage with reduced replication
Wheel Protocol (Pandey et al., 2014)	Replicated data control	Closest intended match when “Quorus” is used for a wheel-based quorum protocol
QTree (Cirisci et al., 2023)	Consensus abstraction	Quorum Tree abstraction for Paxos, PBFT, Raft, and HotStuff
Quorum (Baliga et al., 2018)	Permissioned blockchain	Ethereum-derived consortium ledger with RAFT and IBFT

A common source of confusion is orthographic rather than conceptual. “Quorus” is distinct from “Quorum,” the permissioned blockchain platform built from the Ethereum codebase, and from “Quoracle,” a library for evaluating and choosing read-write quorum systems for real deployments (Baliga et al., 2018, Whittaker et al., 2021). A second source of confusion is disciplinary: in some papers the relevant object is a named framework, whereas in others the query term is only an approximate referent for a broader quorum-system design space.

2. Quorus in quantum federated learning

In "Layerwise Federated Learning for Heterogeneous Quantum Clients using Quorus" (Han et al., 30 Sep 2025), Quorus is a quantum federated learning framework for the realistic setting in which clients have access to quantum hardware with different error properties and different usable circuit depths. The motivating problem is that standard federated learning assumes a common model family, but in the quantum setting deeper circuits generally produce worse outputs on noisy devices and are harder to optimize because of barren plateaus, while each loss estimate is shot-expensive and intermediate measurement is destructive.

The formulation begins with the standard federated objective

$L(x_1,\dots,x_m)=\frac{1}{m}\sum_{i=1}^m L_i(x_i),$

and a parameterized quantum circuit

$$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$

with optimization target

$$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$

The central departure from earlier quantum FL baselines is that Quorus does not force all clients to train only the deepest output of their local model. Instead, it uses a shared layerwise objective so that subnetworks of different depths remain compatible across the federation and deeper clients receive a stronger optimization signal (Han et al., 30 Sep 2025).

This design addresses four constraints stated explicitly in the source: heterogeneous depth limits, expensive measurements, measurement collapse, and hardware heterogeneity. The paper further notes that a naive heterogeneous approach such as quantum HeteroFL can suffer from parameter mismatching and inconsistent objectives across clients, so Quorus treats heterogeneity as a first-class training constraint rather than as a minor implementation detail (Han et al., 30 Sep 2025).

3. Layerwise objective, aggregation, and circuit realizations

The defining objective of Quorus is a layerwise loss with reverse distillation:

$$L_k = \sum_{i=1}^{d_k} L_{\mathrm{ce}}^{i} + \frac{1}{d_k-1}\sum_{i=1}^{d_k}\sum_{\substack{j=1\ j\neq i}}^{d_k} D_{\mathrm{KL}}(p_j\|p_i),$$

where $d_k$ is the depth of client $k$, $L_{\mathrm{ce}}^{i}$ is the binary cross-entropy loss of the classifier at layer $i$, and $D_{\mathrm{KL}}(p_j\|p_i)$ couples layerwise classifiers. The paper contrasts this with Q-HeteroFL, which uses only $L_k = L_{\mathrm{ce}}^{d_k}$ and therefore supervises all parameters only through the final output (Han et al., 30 Sep 2025).

Server-side aggregation is likewise depth-aware. Only parameters shared by clients of sufficient depth are aggregated together, and the server uses circular averaging because PQC parameters are rotation angles. The angle operator is defined as

$$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$0

This makes the aggregation rule geometric on the circle rather than purely Euclidean in parameter space (Han et al., 30 Sep 2025).

Because intermediate measurement collapses the quantum state, Quorus introduces multiple circuit-level realizations of the same training principle. The Layerwise design is the most direct implementation and runs the circuit once per layer, making it shot-expensive. The Ancilla / Blocking design reads layer outputs through ancillas or an operationally equivalent midcircuit-measurement construction. The Funnel design removes operations involving the measured qubit so that all measurements can happen at the end, at the cost of shrinking the active Hilbert space with depth. The paper further studies Staircase, V-shaped, and Alternating ansatz patterns; all use data reuploading via $$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$1 gates, generalized single-qubit rotations $$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$2, and CNOT entanglement, with the V-shaped ansatz chosen as the default because it generally gives the best accuracy across tasks (Han et al., 30 Sep 2025).

A plausible implication is that Quorus is less a single circuit than a family of resource-aware training schemes. The paper itself presents the variants as optimizing different constraints: shot budget, qubit count, midcircuit measurement capability, and optimization space.

4. Empirical profile of the quantum Quorus framework

The empirical study uses binary classification tasks from MNIST and Fashion-MNIST, five clients, heterogeneous depth settings from 2L to 6L, one client per depth level, angle encoding after PCA reduction to 10 features, 128 datapoints per client, 1000 communication rounds, and testing on 3000 points in simulation and 100 points for hardware runs (Han et al., 30 Sep 2025).

The reported headline result is that Quorus “improves testing accuracy by 12.4% on average over the state-of-the-art,” while the detailed comparisons emphasize Q-HeteroFL as the key baseline (Han et al., 30 Sep 2025). The paper reports that Quorus-Layerwise achieves the best average testing accuracy overall; Quorus-Funnel is usually close; Ancilla/Blocking is also close in performance; and differences among the variants are often within about a percentage point. This suggests that variant choice is driven primarily by hardware constraints rather than by a single dominant accuracy hierarchy.

The paper also reports that Quorus increases the magnitude of gradients of higher depth clients and yields higher gradient norms throughout training, especially for earlier layers. In the authors’ interpretation, the layerwise supervision mitigates barren-plateau-like optimization difficulty by providing more direct learning signals to early parameters (Han et al., 30 Sep 2025).

Real-hardware evaluation on IBM superconducting QPUs reinforces the heterogeneity premise. The same depth-5 model can have very different accuracy depending on the device, and on a single noisy machine shallower models tend to outperform deeper ones. The paper also finds that, in the Funnel setting, ensembling layer outputs yields higher accuracy than individual layer classifiers in both ideal simulation and hardware runs. This suggests that Quorus extracts useful information from noisy deep circuits by exploiting the layerwise structure rather than trusting only the terminal measurement (Han et al., 30 Sep 2025).

5. Quorus as a framework for distributed all-pairs computation

In "Scaling Distributed All-Pairs Algorithms: Manage Computation and Limit Data Replication with Quorums" (Kleinheksel et al., 2016), Quorus is a distinct framework aimed at distributed all-pairs problems such as database self-joins, $$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$3-body physics, facial similarity matrices, protein similarity or clustering, and gene co-expression and correlation networks. The problem is to compute every unordered pair

$$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$4

without replicating the full dataset to every process.

The paper’s key construct is a cyclic quorum set $$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$5 with coverage and intersection properties, generated by cyclic shifts of a base quorum:

$$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$6

Its central definition is the all-pairs property:

$$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$7

The proof relies on the connection between cyclic quorums and relaxed difference sets, and the paper states explicitly that the cyclic quorum set defined by cyclic shifts of a relaxed difference set satisfies the all-pairs property (Kleinheksel et al., 2016).

The practical consequence is reduced replication. The paper states that quorum size is

$$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$8

that the resulting structures are up to 50% smaller than dual $$U(\theta)=U_{0:L}(\theta_{0:L})=U_L(\theta_L)\cdots U_1(\theta_1)U_0(\theta_0),$$9 array implementations, and that implementation on the PCIT bioinformatics application yielded a 7× speed up on 8 nodes with 1/3rd the memory usage per process (Kleinheksel et al., 2016). The same results are also summarized as more than 2/3 reduction in memory per process. In this usage, Quorus is not about consensus or replicated storage; it is a combinatorial data-placement strategy for localizing pairwise work.

6. Quorum-system lineage in storage, networking, and sensor systems

The broader conceptual background for both uses of Quorus is quorum theory. In "Read-Write Quorum Systems Made Practical" (Whittaker et al., 2021), a quorum system is described as a collection of subsets of replicas, called quorums, such that any two quorums intersect. For read-write quorum systems, quorums are partitioned into $$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$0 and $$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$1 with safety condition

$$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$2

That paper emphasizes that majority quorums are simple but often suboptimal for latency, throughput, and network load, and introduces Quoracle as a library for evaluating quorum trade-offs under machine heterogeneity and workload skew (Whittaker et al., 2021).

A more specialized replicated-data construction appears in "A Novel Quorum Protocol" (Pandey et al., 2014), where the Wheel Quorum Consensus Protocol imposes a logical wheel structure on replicas. Its read quorum is just the HUB,

$$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$3

while a write quorum requires the HUB plus half of the alternating nodes in the cycle, with size

$$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$4

The source explicitly states that, if “Quorus” refers to the protocol being asked about, the closest intended match is this wheel quorum scheme. Its core claim is minimum read quorum size of one together with fault-tolerant writes and an election quorum that preserves HUB-based access after failures (Pandey et al., 2014).

Quorum ideas are also extended beyond replicated storage. "Optical quorum cycles for efficient communication" (Kleinheksel et al., 2016) uses cyclic quorum sets to prebuild optical cycles that support unicast, multicast, and broadcast without knowing requests a priori; broadcast is achieved with $$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$5 multicasts, and single-edge-failure simulations report greater than 99% average coverage. "GeoQuorum: Load Balancing and Energy Efficient Data Access in Wireless Sensor Networks" (Luo et al., 2011) generalizes quorums from discrete node sets to curves on a sphere and defines load, robustness, and total load metrics; GeoQuorum uses parameterized write circles and read spirals, with guarantee

$$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$6

A further quorum-based direction appears in mutual exclusion, where a distributed deadlock-free algorithm organizes each quorum as a logical ring and circulates requests through the ring to preserve mutual exclusion with message complexity proportional to quorum size rather than full system size (Naimi et al., 2013).

7. Formal abstractions, reconfiguration theory, and adjacent terminology

Several papers recast quorum systems at a more abstract level. "An Algebraic Model For Quorum Systems" (Pellegrini et al., 2020) encodes subsets of processes as Boolean vectors in

$$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$7

and then represents inclusion, intersection, dissemination, and masking conditions by polynomial zero tests. The paper’s stated advantage is that Boolean Gröbner bases can avoid part of the combinatorial computations required to check consistency and availability. "Reconfigurable Heterogeneous Quorum Systems" (Li et al., 2023) moves in a different direction: each participant declares its own quorums, and the theory formalizes consistency, availability, and quorum inclusion together with Byzantine-correct reconfiguration protocols for join, leave, add quorum, and remove quorum. That paper also proves impossibility results showing that certain combinations of policy preservation, availability preservation, and termination cannot be achieved simultaneously, and it characterizes the system graph by a unique sink component (Li et al., 2023).

Consensus protocols can also be viewed through quorums. "Quorum Tree Abstractions of Consensus Protocols" (Cirisci et al., 2023) introduces QTree, a sequential abstraction in which a run of a protocol is represented as a tree of quorum-certified proposals with node statuses in $$\theta^\star=\arg\min_{\theta\in\Theta}L(U,x;\theta).$$8. Safety becomes the claim that all committed nodes lie on a single branch, and the paper shows that Paxos, PBFT, Raft, HotStuff, Multi-Paxos, Cheap Paxos, Stoppable Paxos, Fast Paxos, and Flexible Paxos can be reasoned about in this uniform way (Cirisci et al., 2023).

Finally, “Quorus” should not be conflated with "Performance Evaluation of the Quorum Blockchain Platform" (Baliga et al., 2018). Quorum is a permissioned consortium blockchain derived from Ethereum, with confidentiality features, RAFT for crash fault tolerance, IBFT for Byzantine fault tolerance, and gas set to zero. The resemblance is nominal, not substantive. A plausible implication is that “Quorus” functions less as a single canonical term than as a point of intersection between two naming streams: one centered on quorum systems in distributed computing, and another centered on a specific quantum federated learning framework (Baliga et al., 2018).