Angle Precision as the Bandwidth of Blind Variational Training

Suppose a client wants to train a variational quantum circuit, meaning a quantum circuit with tunable rotation angles that are fitted to data the way neural network weights are. The only quantum computer available is a remote cloud machine the client does not trust. Blind quantum computation lets the client run circuits on that machine without the server learning the circuit, its inputs or its outputs. The client hides each rotation angle by adding a secret random offset. Perfect hiding holds only when the offset is drawn uniformly from the same finite set of angles the protocol uses. So continuous parameters must be rounded onto a coarse lattice before they ever reach the server. Every bit of angle precision, every shot and every circuit evaluation also costs client-prepared quantum states and client–server message rounds. In effect, blind training has a communication channel whose bandwidth is spent per bit of angle precision.

This note proposes porting the toolkit that distributed deep learning built for gradient synchronization overhead into that channel. That toolkit cuts the cost of synchronizing gradients across machines with low-bit messages, error-feedback buffers and shared random projections. The central bet is that a client who keeps a full-precision copy of the parameters and sends only lattice-rounded angles, carrying the rounding error forward the way compressed-gradient methods do, can train blind circuits at 3 to 4 bits of angle precision with little accuracy loss. Naive rounding at the same precision should stall training completely. If this holds, it gives the first resource-accounted recipe for blind variational training. If it fails, we learn how much precision blindness really has to buy.

Core Claim

Blindness forces quantization rather than merely permitting it. In the universal blind protocols surveyed in A hybrid universal blind quantum computation and Ground state blind quantum computation on AKLT state, the server receives each measurement angle shifted by a secret offset. The server's view is independent of the true angle only when that offset is uniform over the angle set itself. Common constructions use multiples of π/4, which is 3 bits per angle. Finer sets need the client to prepare states at proportionally finer precision, and in gadget-based schemes such as Succinct Blind Quantum Computation Using a Random Oracle they need longer gate sequences.

We claim the binding constraint on blind training is therefore angle precision, not just shot count. We further claim that the error-feedback mechanisms that make 1–4-bit gradient communication work classically transfer almost unchanged to this setting. Those mechanisms are SEPARATE's moving-average residual buffer (SEPARATE) and SDP4Bit's trick of quantizing the change between steps rather than the absolute value (SDP4Bit).

The resource accounting is simple. Write $Q = S \cdot E \cdot n(b)$ for the number of client-prepared padded qubits per training step. Here $S$ is shots per circuit, $E$ is circuit evaluations per step (two per parameter under the parameter-shift rule, the standard way to get exact gradients from shifted circuit runs), and $n(b)$ is the number of measured qubits in the blind pattern at $b$ bits of angle precision. The classical client-to-server traffic is $B = Q \cdot b$ bits. Gradient-communication methods attack $b$, $E$ and $S$. We focus on $b$ because it is the factor that blindness itself fixes.

One detail makes the lattice natural for training. For any $b \ge 2$, the parameter-shift offsets of ±π/2 are themselves lattice points. Exact gradients at lattice points can therefore be computed blindly with no extra precision.

Positioning Against Prior Work

The closest prior work on blind learning is Blind quantum machine learning with quantum bipartite correlator. It hides one inner-product estimate between two parties with $O(\log N/\epsilon)$ communication. It is a single-shot primitive with no iterative optimization, no parameter trajectory and no notion of update precision. We take its threat model, an untrusted server with a padded client, and ask what happens over thousands of training steps.

Three quantum federated learning systems motivate the communication side but leave blindness out entirely: Quantum Federated Learning with Quantum Data, Towards Federated Learning on the Quantum Internet, and Optimizing Quantum Federated Learning Based on Federated Quantum Natural Gradient Descent. The third, FQNGD, cuts the number of rounds by following the curved geometry of quantum states, but it sends full-precision plaintext updates and itself notes that it is exposed to server snooping. The survey Quantum distributed deep learning architectures names blind computation as a needed primitive but offers no mechanism.

The method itself comes from classical communication-efficient training. BitDP shows that 1–2-bit messages work if sensitive tensors are kept at higher precision. SDP4Bit shows that quantizing step-to-step differences keeps relative error low. SEPARATE shows that residual buffers keep heavily compressed training from drifting.

Two results constrain the design. First, single-server blindness with a purely classical client is implausible, as shown in On the implausibility of classical client blind quantum computing and Complexity-Theoretic Limitations on Blind Delegated Quantum Computation. We therefore assume a client that can prepare single-qubit states, which keeps the qubit count $Q$ the real cost. Second, the lazy-synchronization line of work, DiLoCo and its scaling laws, does not transfer directly. A blind server cannot take local optimizer steps, because the measurement outcomes it would need are padded. We state that limitation openly rather than force the analogy.

Research Program

The method has four pieces.

The first piece is a lattice-constrained blind trainer. The client keeps master parameters $\phi$ in full precision and an error buffer $e$. At each step it sends the angles $\mathrm{round}_b(\phi + e)$ through the blind protocol, then updates the buffer as $e \leftarrow (\phi + e) - \mathrm{round}_b(\phi + e)$. It computes parameter-shift gradients at the rounded point and updates $\phi$. Following SDP4Bit, a variant quantizes the step-to-step change in angle instead of the absolute angle. Following SEPARATE, a variant uses a moving-average buffer with factor $\beta$, which lets us test whether that method's sensitivity to $\beta$ carries over.

The second piece is a resource meter. It counts $Q$, $B$ and protocol rounds for each run, so that methods are compared at equal blind cost rather than equal step count.

The third piece is a blindness audit. For small instances of 4 to 6 qubits, we simulate the full padded measurement protocol and estimate the distance between the server's transcript distributions under two different parameter settings. This confirms that rounding to the lattice, together with error feedback held entirely on the client, adds no leakage. It should not, since $e$ never leaves the client, but the audit makes the claim checkable.

The fourth piece is a secondary lever on shots, $S$. Signs of parameter-shift differences need fewer shots to estimate than magnitudes. We therefore test a block-scaled sign update in the style of BAS. It is included only as an ablation, to see whether savings in $b$ and in $S$ compound.

For an honest server, the decoded outputs of a blind run equal those of a plain run with lattice angles. Training-quality experiments can therefore be done in ordinary noisy circuit simulation at scale, with the full blind simulation reserved for the audit.

Baselines

The do-nothing reference point is naive nearest rounding to the protocol lattice with no error buffer. This is what one gets by plugging an off-the-shelf optimizer into a blind protocol. With the π/4 lattice and typical learning rates, most updates are smaller than half a lattice step, so we expect parameters to freeze. Beating this baseline should be easy. Its purpose is to show that the precision problem is real rather than hypothetical.

The strongest existing competitor is continuous-angle, non-blind training with FQNGD on the same circuits. On MNIST binary classification of digits {2,5}, Optimizing Quantum Federated Learning Based on Federated Quantum Natural Gradient Descent reports 99.32% accuracy, and 99.12% on ternary {1,3,7}. This is an upper bound on what blindness can hope for. We will rerun it with the same circuit architecture, six-way data split, shot budget and step budget, and give each method an equal learning-rate sweep. Plain Adam at continuous precision serves as a second reference. "Beating" this baseline means falling within one accuracy point of it while operating at the lowest $b$ that achieves this, with $Q$ and $B$ reported for both.

On the 8-qubit cluster-state task from Quantum Federated Learning with Quantum Data, the reference is that paper's reported near-99% test accuracy, dropping from about 99.2% to about 98.6% under non-IID splits. For FashionMNIST, PneumoniaMNIST and Moons, no reported numerical result was found on Lacuna for Towards Federated Learning on the Quantum Internet. There we generate our own continuous-precision baseline.

The key ablations hold $b$ fixed and isolate the error buffer: no buffer, stochastic rounding without a buffer, an error buffer, and a moving-average buffer. A second ablation drops to $b = 3$ only on sensitive parameters, such as the final-layer or data-encoding angles. It mirrors BitDP's practice of keeping sensitive tensors at higher precision, and tests whether mixed precision helps.

Why not just…?

Why not just use a very fine angle set so quantization never matters? Because precision is exactly what blindness charges for. In the accounting above, $B$ grows linearly in $b$. In single-server protocols, client state preparation must be accurate to about $2^{-b}$. In gadget-based schemes, $n(b)$ grows with the gate sequence needed per rotation. A fine lattice is a legitimate point on the curve, and we will include $b = 8$ as a run. The proposal is worth pursuing only if accuracy at $b = 3$–4 comes close to it. If accuracy only recovers at large $b$, the honest conclusion is that blind training must pay for precision, and the meter will say how much.

Why not just use stochastic rounding, which is standard quantization-aware training? This is a real threat, because unbiased stochastic rounding also lets small updates move parameters in expectation. Our ablation runs it head to head with the error buffer at equal $Q$. Classical evidence that residual buffers matter under extreme compression, from SEPARATE and BitDP, suggests the buffer wins at 3 bits, where rounding variance is large relative to the update size. If stochastic rounding matches it, we adopt the simpler method and the contribution narrows to the blind cost model and the precision threshold.

Why not just rely on device noise for privacy instead of blindness? The quantum differential privacy survey Bridging Quantum Computing and Differential Privacy treats hardware noise as a privacy mechanism. That guarantee is statistical and concerns individual data records. It does not hide the circuit or its parameters from the operator, which is the threat here. The two guarantees are complementary rather than substitutes.

Why not just use a cheaper gradient estimator such as random-direction finite differences? That approach attacks $E$, not $b$. It is orthogonal and can be combined with our method; it does not replace it. We note it as follow-up work rather than a competing explanation of the results.

Proposed Experiments

The decisive check is a precision sweep over $b$ from 2 to 8 bits on MNIST {2,5} and {1,3,7} and on the cluster-state task. Each value of $b$ is run with naive rounding, stochastic rounding and error feedback, under depolarizing noise at three strengths. Results are plotted as accuracy against padded qubits $Q$.

The proposal succeeds if three things hold. Error feedback at $b = 3$, the native π/4 lattice, comes within one point of the FQNGD continuous result of 99.32%. Naive rounding at the same $b$ stalls near chance. The blindness audit finds transcript distributions indistinguishable within estimator error.

Secondary checks probe how robust the method is. One test checks whether SEPARATE's sensitivity to $\beta$ reappears in the blind setting. Another tests whether sign-based shot savings compound with low $b$. A third measures whether non-IID splits across several blind clients sharing one server widen the gap between rounded and continuous training. The third test is the closest analogue to the drift problem that motivated DiLoCo and WASH.