Private Hyperbolic Inference at Euclidean Round Cost

Hyperbolic neural networks represent tree-like data, such as taxonomies, evolutionary lineages, and citation hierarchies, in a curved space whose volume grows exponentially with radius. Because a tree also grows exponentially with depth, these models can match or beat flat-space models while using far fewer dimensions. In private inference, where a model runs on secret-shared or encrypted inputs, small width should translate directly into fewer bytes on the wire. The catch is the cost of each layer. Hyperbolic layers are built from coupled vector norms, square roots and hyperbolic sines, and generic secure-computation toolkits evaluate these as long chains of interactive subprotocols. Over a wide-area network, every extra round-trip costs 100–170 ms, so the width savings are lost to latency.

This note proposes a compiler, plus an accompanying study, built on one structural observation. Write a Lorentz-model network in "point-to-hyperplane" form: each layer is a linear map in ambient coordinates, followed by per-coordinate scalar functions, with the only coupling across coordinates coming from quadratic forms. Such a network can be compiled so that each layer needs roughly the same number of online rounds as a Euclidean layer under existing function-secret-sharing compilers. The research question is whether this turns hyperbolic geometry's low-dimension advantage on hierarchical data into a measurable communication and latency advantage over the obvious alternative, a wider Euclidean model run through the same compiler.

Core Claim

Function secret sharing (FSS) is a two-server technique in which each server holds a key that lets it evaluate its share of a function on a publicly masked input in very few rounds. FuseFSS uses it to compile scalar non-linearities such as GELU and LayerNorm scaling into a two-call pattern: one packed comparison, then one interval lookup that retrieves polynomial coefficients, followed by local Horner evaluation. It reports 1.24×–1.50× end-to-end speedups over Sigma on GLUE. FuseFSS explicitly cannot handle vector reductions such as sums and norms. A New PPML Paradigm for Quantized Models fuses single-input single-output chains into private lookup tables. It hits exponential table growth (256^k for k inputs) when an operator takes several inputs. The research file frames hyperbolic operations as falling squarely into both gaps, because Minkowski inner products, norms and distances couple all coordinates.

Our claim is that, for the Lorentz model, this framing is too pessimistic. The coupling is almost entirely quadratic, and a quadratic form is a local sum of single-input squares. Sums of secret shares cost zero rounds, so the multi-input barrier dissolves.

A layer in the style of Fast and Geometrically Grounded Lorentz Neural Networks and the PLFC layer of Intrinsic Lorentz Neural Network computes signed distances to learned hyperplanes, applies a scalar activation, and recovers the time coordinate. Concretely, for input $x=(x_0, z)$ on the hyperboloid, the output space coordinates are $z'_j = \phi_j(\langle w_j, x\rangle_L)$, where $\langle w,x\rangle_L = -w_0x_0 + \sum_i w_i z_i$ is the Minkowski product and $\phi_j$ is a scalar function. The new time coordinate is

$$x'_0 = \sqrt{1 + \textstyle\sum_j (z'_j)^2}.$$

The server's weights $w_j$ are plaintext, so the Minkowski products are local linear operations on shares. Each $\phi_j$ is a single-input scalar function. The squared norm is a sum of single-input squares. The square root is a single-input scalar function.

If one lookup call returns both $\phi_j(u_j)$ and $\phi_j(u_j)^2$ as a two-output table, the norm costs zero extra calls. The whole layer then needs two scalar lookup calls: activation-and-square, then square root. FuseFSS needs about the same for one Euclidean non-linearity. The classification head is cheaper still. A point-to-hyperplane distance is $\mathrm{arcsinh}(\langle w,x\rangle_L/\|w\|_L)$, which is linear in $x$ with a public normalizer, followed by a monotone function. An argmax over classes therefore never has to evaluate the arcsinh at all.

Inference-time Lorentz batch normalization contributes a re-centering step. Re-centering to a fixed mean is a Lorentz boost, which is a linear map in ambient coordinates. It can be folded into the preceding linear layer in the same way that Low-Complexity Deep CNNs on FHE folds batch normalization into convolutions and HEMET merges constants into polynomial coefficients. The radial rescaling step, a scalar function of $x_0$ multiplied into $z$, costs one multiplication round. That is the only hyperbolic-specific round we expect to remain.

Relation to Prior Work

The motivating evidence comes from two places. CrypTen shows that once local arithmetic is fast, communication dominates: 63% of runtime in 8-party speech recognition. CrypTen also evaluates non-linearities with iterative Newton–Raphson and Householder approximations, one interactive chain per operation. That is exactly how a naive secure hyperbolic layer would run. On the WAN side, Trifecta and Constant-Round Private Decision Tree Evaluation show that round count, not compute, decides latency at 100–170 ms RTT. Both buy fewer rounds with exponential communication volume, $2^l$ per gate and $2^{\text{depth}}$ per tree respectively. Our decomposition aims to cut rounds without that exponential blow-up, because it never forms multi-input tables.

Prior work on hierarchy plus encryption constrains the design. LinGCN fuses graph convolution, normalization and degree-2 polynomial activations under homomorphic encryption. It still needs 742 seconds for a 3-layer model and stays Euclidean. Replacing hyperbolic functions with degree-2 polynomials would also flatten the curvature that makes hyperbolic models useful. We therefore use exact-up-to-quantization lookups rather than low-degree polynomials, and we work in interactive two-server FSS rather than pure homomorphic encryption.

The method comes from three sources. We reuse FuseFSS's comparison-plus-lookup machinery and shape-hiding key padding. We reuse the point-to-hyperplane layers of FGG-LNN and ILNN, which matter for us because they avoid round-tripping through tangent spaces, the "Euclidean leakage" that ILNN identifies. We contrast this with the Poincaré-ball operations of Hyperbolic Neural Networks. Möbius addition and the Poincaré distance divide by products of conformal factors, a genuinely multi-input non-linearity. One prediction of this proposal is that Lorentz models are cryptographically much cheaper than Poincaré models, even though they are equivalent in plaintext.

Research Program

We will build the compiler as an extension of a FuseFSS-style two-server semi-honest pipeline. The extension has four parts. First, two-output scalar tables that return $f(u)$ and $f(u)^2$ in one call. Second, local quadratic-form reductions. Third, folding of inference-time Lorentz boosts into adjacent linear maps. Fourth, an optional bivariate table for fusing the square root into the next layer's activation, which is feasible for 8-bit inputs at 65,536 entries. We will report a round count per layer type, derived analytically and confirmed by instrumentation, for Lorentz and Poincaré layers under three settings: the naive modular approach, FuseFSS as-is, and our compiler.

The main technical risk is numeric range. In the Lorentz model, radius encodes depth, so $x_0 \approx \cosh r$ grows exponentially with hierarchy depth. Fixed-point rings and 8-bit tables may then clip or wrap. We will train hyperbolic models with a radius cap and quantization-aware training. We will measure accuracy as a function of ring bit-width and radius cap, and compare against the bit-width Euclidean models need. If hyperbolic models need much wider rings, part of the byte savings is lost, and the study will quantify how much.

Baselines

The naive reference point is the same Lorentz network run under modular, layer-by-layer secret-sharing evaluation in CrypTen. Norms use Beaver multiplications, and square roots and hyperbolic functions use its iterative approximations. This shows what hyperbolic private inference costs today. Beating it means a large reduction in online rounds per layer at equal accuracy. It is a weak bar, included to quantify the gap rather than to claim a win.

The strongest competitor is a Euclidean MLP or GCN of matched depth, compiled with FuseFSS, with width swept upward until it reaches the hyperbolic model's accuracy. This is the strongest competitor because it uses the most efficient published fused compiler on the cheapest-to-secure architecture. The research file contains no reported secure-inference result on our hierarchical benchmarks; FuseFSS's reported figures are the GLUE speedups above. We will therefore run both models ourselves, on the same data splits and machines, with equal hyperparameter-search budgets and the same quantization and ring settings. Plaintext targets come from the cited papers. ILNN reports 78.41% on CIFAR-100 against 77.72% for Euclidean ResNet-18, and MCC 64.90 against 51.94 on TEB pseudogenes. HNN reports 96.91% against 89.62% on PREFIX-10%. Beating this baseline means strictly lower online bytes and wall-clock WAN latency at equal or higher accuracy, with no more rounds.

A third baseline is a Euclidean backbone with only a Lorentz point-to-hyperplane head. As argued above, that head is cryptographically nearly free. Two ablations isolate the key ingredient. One removes the two-output tables, so the norm is computed by a separate multiplication round. The other disables boost folding.

Why not just…?

Why not just make the Euclidean model wider and use FuseFSS unchanged? This is the real threat. Communication in secret sharing scales roughly linearly with width, so a hyperbolic win requires the Euclidean model to need a substantially larger width to match accuracy. The evidence for this is strong only on genuinely hierarchical, low-dimension tasks: WordNet subtrees, PREFIX-10% and TEB. On CIFAR-10, FGG-LNN merely ties Euclidean ResNets at 94.66% versus 94.58%, so we expect no advantage there and will report it as a negative control. The accuracy-versus-bytes Pareto sweep settles this question directly.

Why not just add a hyperbolic head to a Euclidean backbone? If most of the hierarchical benefit lives in the final hyperplane distances, this hybrid gets it at almost zero cryptographic cost, and the full compiler is unnecessary. ILNN's own gains from swapping only the last layer, up to 1.22 points on AIRPORT, CORA and PUBMED, suggest the head carries real value. We will run the hybrid at matched bytes. If it matches the fully hyperbolic model, we will report that as the main practical finding.

Why not just use pure homomorphic encryption and avoid rounds entirely? Zero rounds come at the cost of minutes of server compute: 742 seconds for LinGCN's 3-layer model. Pure homomorphic encryption also forces polynomial approximations, which cost Primer's BERT-base about 7 accuracy points (~77% versus 84.6%) and would distort curvature in our setting. We will not rebuild a homomorphic-encryption pipeline, but we will cite this gap as the reason for choosing interactive FSS.

Why not just discretize the hierarchy and use constant-round tree evaluation? Cheng et al.'s 5-round protocol scales communication as $2^{\text{depth}}$, needed 135 MB on Digits-15, and becomes impractical beyond depth 15. It also yields no dense representation. We will include it only on the WordNet tasks, as a latency reference point.

Proposed Experiments

The datasets are WordNet subtrees and PREFIX-10% from HNN, AIRPORT, CORA and PUBMED for node classification, TEB pseudogenes and GUE Covid variants for genomic lineages, and CIFAR-100 and CIFAR-10 as the controls where hierarchy matters less. Latency will be measured on a simulated WAN at 100 ms RTT and 160 Mbps, following Trifecta's setting, and on a three-continent deployment mirroring the ~170 ms SF–Singapore–Frankfurt testbed. The two-server protocol uses two of those sites. We will report online rounds, online and offline bytes, key size, wall-clock latency and task accuracy.

The decisive check is the Pareto sweep on TEB and WordNet. The claim holds if the Lorentz model at small width reaches the wide Euclidean model's accuracy at lower online bytes and equal round count, and if the width ratio survives the ring bit-width the Lorentz model actually needs. The claim fails if the Euclidean model matches at equal bytes, or if the hyperbolic-head hybrid captures the gain. A secondary check compares Lorentz and Poincaré round counts, to test whether model choice dominates cryptographic cost.