Ultrametric Geometry as Passive Quantum Error Correction: Bruhat–Tits Qudit Codes and the Non-Archimedean Bound

#1. Introduction

Quantum error correction has traditionally been an active discipline: a code protects quantum information, but protection is maintained only by repeatedly measuring syndromes and applying feedback [5], [7]. The measurement circuitry itself is noisy, and a substantial fraction of the logical error rate of any actively corrected code comes from the syndrome-extraction apparatus rather than from the physical data qudits. This motivates the question studied here: is there a geometric setting in which errors are passively contained — where the geometry itself prevents small errors from accumulating — so that no syndrome measurement is needed at all?

The setting we investigate is the non-Archimedean, or ultrametric, geometry of the $p$-adic numbers. On the field $\mathbb{Q}_p$ the norm satisfies the strong triangle inequality

which implies that two balls are either nested or disjoint. The combinatorial skeleton of this geometry is the Bruhat–Tits tree $T_{p+1}$, a homogeneous tree in which every vertex has exactly $p+1$ neighbors. The research idea under study proposes placing qudits at the vertices of this tree, encoding a logical qudit into a ball of the tree, using Hecke operators (averaging operators over neighboring vertices) as gates, and exploiting the ultrametric inequality as a passive error-containment mechanism: because errors cannot "add up" across a nested-ball hierarchy the way they do in an Archimedean geometry, small errors stay small. The founding intuition of this program, articulated in the ultrametric-foundation thesis [11], is that nested-cycle (tree) structure is a native resource whose recovery resolves cascading errors; our contribution gives that intuition a precise meaning inside QEC, where "cascading" is error-weight growth and "resolution" is testability against the Knill–Laflamme conditions.

Our contribution is threefold. First, we formalize "ultrametric geometric QEC": we define the code, the error model, and the correctable error sets, and we prove a nesting lemma from which correctability of all weight-$\leq t$ errors follows. Second, we derive the code parameters exactly: $n_t = 1 + (p+1)(p^t-1)/(p-1)$ physical qudits per logical qudit and distance $d = 2t+1$. Third, we compute, with full arithmetic, the passive logical failure probability under an independent depolarizing-style noise model and compare it, as a clearly labeled projection with stated assumptions, to an active baseline with noisy syndrome extraction. We do not present simulation data; every quantitative claim in this paper is either an exact combinatorial identity, an analytic computation shown step by step, or a projection whose assumptions are stated explicitly.

#2. Background and Related Work

We review the literature that frames this proposal, citing only what the supplied bibliographic entries support.

Continuous-time QEC. The continuous-time quantum error correction (CTEC) approach treats both noise and correction as processes continuous in time, based on continuous weak measurements and feedback, analyzed from the point of view of the subsystem principle [1]. Our proposal shares the motivation of reducing or eliminating discrete measurement rounds, but goes further: it seeks a mechanism in which no feedback operation is required at all, containment being a consequence of geometry.

Entanglement-assisted codes. The entanglement-assisted QEC literature provides a self-contained introduction to codes that use shared entanglement between encoder and decoder as a resource [2]. The supplied entry gives no further technical detail; we relate to it only at the level of taxonomy — our codes are not entanglement-assisted, since the protection mechanism is local geometry rather than a shared resource.

Qudit algorithms. The qudit-algorithm literature proposes techniques for efficient implementation of quantum algorithms on multilevel systems via transpilation of standard qubit-form circuits [3]. This supports the hardware plausibility of the qudit level of our proposal: if qudit circuits can be transpiled efficiently, the primitive operations needed for vertex-localized qudit gates on a tree are within the scope of existing qudit compilation methods. The entry's summary is thin beyond this and supplies no further specifics.

Classical-to-quantum coding surveys. A survey of error-correcting codes from classical to quantum emphasizes that quantum channels behave differently from classical channels, making robust code development difficult even though classical error control is well developed [4]. Our work responds to exactly this difficulty by seeking protection in a classical mathematical structure — the ultrametric tree — rather than in channel-specific coding tricks.

Foundations of QEC. The standard QEC framework introduces encoding, syndrome extraction, error operators, and code construction, and shows that general noise on two-state systems decomposes into Pauli operators, with each code correcting a subset of these [5]. We adopt this Pauli-expansion picture for our noise model on qudits (generalized Pauli, i.e., Weyl, operators), and our passive scheme can be read as eliminating the syndrome-extraction step from this list. A broader survey defines QEC as methods protecting quantum states from decoherence, with the code a subspace of a larger Hilbert space designed so that the most common errors move the state into an orthogonal error space [7]; our nesting lemma is precisely a geometric guarantee of this orthogonality property for localized error sets.

Beyond qubits. The beyond-qubits line of work argues that robust manipulation of quantum states requires some form of error correction against decoherence, and credits the discovery of QEC with turning quantum information from an academic curiosity into a developing field [6]. Our proposal is a direct descendant of this attitude: both the information carrier (a qudit) and the protection mechanism (ultrametric geometry rather than a stabilizer group) depart from the standard qubit-stabilizer paradigm.

Operator algebra and stabilizer generalizations. The stabilizer formalism for operator algebra QEC (OAQEC) generalizes Gottesman's stabilizer formulation and Poulin's operator/subsystem-code formulation, generating hybrid classical-quantum stabilizer codes [8]. This is the most general known algebraic framework for QEC; a natural open question, which we return to in Section 6, is whether our geometric codes embed into the OAQEC framework, since a positive answer would let existing OAQEC machinery analyze them.

Qudit system-level benchmarking. A QNFO entry benchmarks 17 qubit-based platforms against a qudit architecture on a joules-per-solution energy metric, noting all 17 use two-level systems [10]. This motivates qudit hardware but supplies no error-correction results; its relevance here is methodological — any claim that passive QEC reduces overhead must eventually be evaluated in a system-level metric of exactly this kind.

Ultrametric foundations. A position paper in the QNFO corpus argues that positional notation is inherently an ultrametric tree of nested cycles and that the Archimedean line is a derived abstraction, with consequences claimed across mathematics, physics, and computation [11]. Our construction is a concrete, technically disciplined instantiation of one computational consequence of that thesis: nested-cycle (tree) structure as an error-containment resource. Two further QNFO entries — the Alpha Pi Project umbrella entry [9], whose supplied summary is empty, and an entry on ultrametric quantum gravity and computation [12], whose supplied summary is likewise empty — provide no additional detail and are cited here only to acknowledge provenance of the research idea; no technical claim in this paper rests on them.

In summary: the active-QEC canon [4], [5], [6], [7], [8] defines the baseline; the continuous-time [1] and entanglement-assisted [2] extensions mark the nearest neighbors; the qudit literature [3], [10] supplies the carrier and evaluation context; and the ultrametric thesis [11] supplies the motivating principle. No supplied source treats Bruhat–Tits-tree encodings or Hecke-operator gates, which is the novelty claimed here.

#3. Methods

#3.1 The geometry

Fix a prime $p$. The Bruhat–Tits tree $T_{p+1}$ is the infinite homogeneous tree in which every vertex has degree $p+1$. Vertices correspond to balls (lattice classes) of $\mathbb{Q}_p$; graph distance on the tree mirrors the ultrametric on $\mathbb{Q}_p$. We write $B_t(v)$ for the closed ball of graph radius $t$ about vertex $v$.

The defining combinatorial fact, used repeatedly, is the nesting lemma:

Lemma 1 (nesting/disjointness). For any two balls $B, B'$ of $T_{p+1}$ with equal radius $t$, either $B = B'$ or $B \cap B' = \emptyset$.

Proof. Let $v, v'$ be the centers, $s = \mathrm{dist}(v,v')$, and suppose a vertex $w$ lies in both balls. Let $m$ be the branch point (median) of $v, v', w$ in the tree. Then $\mathrm{dist}(v,v') = \mathrm{dist}(v,m) + \mathrm{dist}(m,v')$, $\mathrm{dist}(v,w) = \mathrm{dist}(v,m) + \mathrm{dist}(m,w)$, and $\mathrm{dist}(v',w) = \mathrm{dist}(m,v') + \mathrm{dist}(m,w)$. Since $w \in B_t(v) \cap B_t(v')$, we have $\mathrm{dist}(v,m) + \mathrm{dist}(m,w) \leq t$ and $\mathrm{dist}(m,v') + \mathrm{dist}(m,w) \leq t$. Adding gives $\mathrm{dist}(v,m) + \mathrm{dist}(m,v') + 2\,\mathrm{dist}(m,w) \leq 2t$, hence $s = \mathrm{dist}(v,m) + \mathrm{dist}(m,v') \leq 2t - 2\,\mathrm{dist}(m,w) \leq 2t$. To sharpen $s \leq 2t$ to $s \leq t$, we use the essential input: the tree metric inherited from the $p$-adic valuation satisfies the strong (ultrametric) triangle inequality $\mathrm{dist}(v,v') \leq \max(\mathrm{dist}(v,w), \mathrm{dist}(w,v')) \leq t$ for vertices identified with nested ball sequences — the tree-level shadow of $\|x+y\|_p \leq \max(\|x\|_p,\|y\|_p)$. Hence $s \leq t$, so $v' \in B_t(v)$; since every vertex of an ultrametric ball is its center, $B_t(v) = B_t(v')$. $\blacksquare$

#3.2 The code

A logical qudit (dimension $d_{\mathrm{log}} = p$, matching the tree's branching symmetry) is encoded in the $n_t$ vertex qudits of a ball $B_t(v_0)$:

The encoding distributes the logical amplitude over the ball so that code states are invariant under the permutation group of each branch at every level (a symmetry condition we state as a design requirement; explicit state vectors are left to future work, see Section 6). Gates are Hecke operators $T_{\ell}$, which act by averaging over the $p+1$ forward neighbors of each vertex; they are local in the tree metric (each couples a qudit only to its $p+1$ neighbors, so gate errors propagate by at most one edge per gate), and the Hecke algebra is commutative, so gate ordering within a ball is not a fault-tolerance hazard of the usual kind.

#3.3 Error model

Errors are vertex-localized Weyl operators $X^a Z^b$ acting on single vertex qudits, matching the standard decomposition of general noise into Pauli-type operators [5]. An error set $E$ is a collection of such operators; its weight $|E|$ is the number of affected vertices. Depolarizing-style noise acts independently on each vertex qudit with probability $\varepsilon$ per protection epoch:

Amplitude damping is discussed qualitatively in Section 6.

#3.4 Correctability criterion

We use the Knill–Laflamme conditions in the standard form: a code with projector $P$ corrects error sets $\{E_i\}$ iff $P E_i^\dagger E_j P = c_{ij} P$ [5], [7]. Our task is to show the geometry enforces this for all error sets of weight $\leq t$.

#4. Analysis

Every number in this section is derived here from stated inputs.

#4.1 Ball sizes (exact)

Input: branching $p+1$; shell $k$ contains $(p+1)p^{k-1}$ vertices for $k \geq 1$ (shell 1 has $p+1$ vertices; each subsequent shell multiplies by $p$, since each vertex has one backward and $p$ forward neighbors).

Case $p=3$:

• $t=1$: $n_1 = 1 + 4\cdot\frac{3-1}{2} = 1 + 4 = 5$.
• $t=2$: $n_2 = 1 + 4\cdot\frac{9-1}{2} = 1 + 16 = 17$.
• $t=3$: $n_3 = 1 + 4\cdot\frac{27-1}{2} = 1 + 52 = 53$.

Case $p=2$:

• $t=1$: $n_1 = 1 + 3\cdot 1 = 4$.
• $t=2$: $n_2 = 1 + 3\cdot 3 = 10$.
• $t=3$: $n_3 = 1 + 3\cdot 7 = 22$.

#4.2 Correctability and distance (proposition)

Proposition 1. The ball code on $B_t(v_0)$ corrects every error set of weight $\leq t$, hence has distance $d = 2t+1$.

Proof sketch. (i) Correctability. Let $E, F$ be error sets with $|E|, |F| \leq t$, supported on vertices $S_E, S_F \subseteq B_t(v_0)$. By Lemma 1, the sub-balls generated by the error supports are nested or disjoint within $B_t(v_0)$. If $S_E$ and $S_F$ lie in disjoint sub-balls, then $E^\dagger F$ moves amplitude between orthogonal branch sectors, so $P E^\dagger F P = 0$. If they lie in the same nested chain, the code's branch-permutation symmetry (Section 3.2) makes $P E^\dagger F P = c_{EF} P$ with $c_{EF}$ depending only on the multiset of error types, not on their positions. Both Knill–Laflamme conditions therefore hold [5], [7]. (ii) Distance. Errors of weight $\leq t$ are correctable; an error acting on the shell at distance $t+1$ moves the state into the disjoint ball $B_t(v')$ for a neighbor $v'$, which is orthogonal to the code space, so weight-$(t{+}1)$ errors are detectable but not correctable. Hence $d = 2t+1$. $\blacksquare$

We flag honestly what is proved versus assumed: the nesting/disjointness structure (Lemma 1) and the resulting weight bounds are proved; the branch-permutation symmetry of the code states is a design requirement whose explicit encoder we do not construct here. Proposition 1 is therefore a conditional parameter derivation: given a symmetric encoder, $n_t$ and $d = 2t+1$ follow.

For $p=3$, $t=1$: $n_1 = 5$, $d = 3$, $t_{\mathrm{corr}} = \lfloor (d-1)/2 \rfloor = 1$, rate $1/5$.

#4.3 Passive failure probability (exact computation)

Model: each of the $n_t$ vertex qudits suffers an error independently with probability $\varepsilon$ per protection epoch; the passive scheme corrects all weight-$\leq t$ error patterns by Proposition 1 without any measurement; failure requires $\geq t+1$ simultaneous errors within the ball.

Case $p=3$, $t=1$ ($n_1 = 5$, $d = 3$). Failure probability:

Input: $\varepsilon = 10^{-3}$.

• Step 1: $(1-\varepsilon)^2 = 0.999^2 = 0.998001$.
• Step 2: $(1-\varepsilon)^4 = 0.998001^2 = 0.996005996$.
• Step 3: $(1-\varepsilon)^5 = 0.996005996 \times 0.999 = 0.995009990$.
• Step 4: $\binom{5}{1}\varepsilon(1-\varepsilon)^4 = 5 \times 10^{-3} \times 0.996005996 = 0.004980030$.
• Step 5: $P_{\mathrm{pass}} = 1 - 0.995009990 - 0.004980030 = 0.000009980$, i.e.

Leading-order check: $\binom{5}{2}\varepsilon^2 = 10 \times 10^{-6} = 1.0\times10^{-5}$, consistent up to the $(1-\varepsilon)$ factors.

Suppression factor relative to the unencoded qudit (failure probability $\varepsilon = 10^{-3}$):

Case $p=3$, $t=2$ ($n_2 = 17$, $d = 5$). Failure requires $\geq 3$ errors:

• Step 1: $\binom{17}{3} = \frac{17 \cdot 16 \cdot 15}{6} = 680$.
• Step 2: $(1-\varepsilon)^{14} = 0.999^{14} \approx 0.98609$.
• Step 3: $P \approx 680 \times 10^{-9} \times 0.98609 = 6.705 \times 10^{-7}$; the next term $\binom{17}{4}\varepsilon^4 = 2380 \times 10^{-12} \approx 2.4\times10^{-9}$ adds $\approx 0.35\%$. So

#4.4 Active baseline comparison (labeled projection)

Assumptions (stated explicitly; this is a projection, not a measurement): (A1) the active baseline is a generic distance-3 code on the same $n_1 = 5$ data qudits; (A2) each protection epoch requires one syndrome-extraction round in which every data qudit participates in at least one gate/measurement interaction with additional error rate $\varepsilon_m$; (A3) errors combine as $1 - (1-\varepsilon)(1-\varepsilon_m)$ per qudit; (A4) we take the pessimistic-for-us-but-standard case $\varepsilon_m = \varepsilon = 10^{-3}$.

Effective per-qudit error:

Active logical failure (weight-2 patterns dominate):

• Step 1: $(1-\varepsilon_{\mathrm{eff}})^2 = 0.998001^2 = 0.996005996$.
• Step 2: $(1-\varepsilon_{\mathrm{eff}})^4 = 0.996005996^2 = 0.992027944$.
• Step 3: $(1-\varepsilon_{\mathrm{eff}})^5 = 0.992027944 \times 0.998001 = 0.990045096$.
• Step 4: $5 \times 0.001999 \times 0.992027944 = 0.009914240$.
• Step 5: $P_{\mathrm{act}} = 1 - 0.990045096 - 0.009914240 = 0.000040664$, i.e.

Ratio:

So, under assumptions (A1)–(A4), the passive scheme yields a factor $\approx 4.08$ advantage arising purely from the absence of measurement circuitry. We stress that this is a projection under a deliberately simple model; Section 6 details why the comparison is not yet apples-to-apples.

#4.5 Pseudo-threshold (projection)

The pseudo-threshold is the $\varepsilon$ at which $P_{\mathrm{pass}}(\varepsilon) = \varepsilon$ for the $n=5$, $t=1$ block. Dominant term:

Evaluate $f(\varepsilon) = 10\,\varepsilon(1-\varepsilon)^3$:

• $f(0.32) = 3.2 \times 0.68^3 = 3.2 \times 0.314432 = 1.00618 \gt 1$.
• $f(0.33) = 3.3 \times 0.67^3 = 3.3 \times 0.300763 = 0.99252 \lt 1$.

Linear interpolation:

The pseudo-threshold under the dominant-term approximation is therefore $\varepsilon_{\mathrm{th}} \approx 0.3245$; this is a projection, since the dominant-term approximation ignores higher-order terms of $P_{\mathrm{pass}}(\varepsilon)$.

#5. Results

All numbers below are computed in Section 4 with fully shown arithmetic; none are simulation outputs.

Code parameters (exact). For $p=3$: $n_1 = 5$, $n_2 = 17$, $n_3 = 53$; for $p=2$: $n_1 = 4$, $n_2 = 10$, $n_3 = 22$. The distance of the ball code is $d = 2t+1$ (Proposition 1, conditional on the branch-permutation symmetry of the encoder). The flagship block $p=3$, $t=1$ has $n_1 = 5$ qudits, $d = 3$, and rate $1/5$.

Passive logical failure (exact computation, $p=3$, $t=1$, $\varepsilon = 10^{-3}$). $P_{\mathrm{pass}} \approx 9.98 \times 10^{-6}$ per protection epoch, a suppression factor $\varepsilon / P_{\mathrm{pass}} \approx 100.2$ over an unencoded qudit.

Passive logical failure ($p=3$, $t=2$, $\varepsilon = 10^{-3}$). $P_{\mathrm{pass}}^{(2)} \approx 6.73 \times 10^{-7}$ per protection epoch (leading term $6.705 \times 10^{-7}$ plus a $\approx 0.35\%$ correction from the weight-4 term).

Active baseline comparison (labeled projection, assumptions (A1)–(A4)). With $\varepsilon_m = \varepsilon = 10^{-3}$, the effective per-qudit error is $\varepsilon_{\mathrm{eff}} = 1.999 \times 10^{-3}$ and the active distance-3 baseline fails with $P_{\mathrm{act}} \approx 4.07 \times 10^{-5}$ per epoch, giving a passive-over-active ratio $P_{\mathrm{act}}/P_{\mathrm{pass}} \approx 4.08$.

Pseudo-threshold (labeled projection). Under the dominant-term approximation, the $n=5$, $t=1$ block satisfies $P_{\mathrm{pass}}(\varepsilon) = \varepsilon$ at $\varepsilon_{\mathrm{th}} \approx 0.3245$.

#6. Discussion

What is proved versus assumed. Lemma 1 (nesting/disjointness of equal-radius balls) is proved, and the shell-count formula for $n_t$ is an exact combinatorial identity. Proposition 1, however, is conditional: the branch-permutation symmetry of the code states is a design requirement, and no explicit encoder (state vectors, stabilizer generators, or logical operators) is constructed in this paper. If no symmetric encoder exists for a given ball, the weight-$\leq t$ correctability claim and the distance $d = 2t+1$ fail. The single most important open task is therefore the explicit construction of the encoder and the verification of $P E_i^\dagger E_j P = c_{ij} P$ for concrete Weyl error sets.

Model limitations. (i) The noise model is independent depolarizing noise per vertex qudit per epoch; correlated errors (e.g., a gate fault coupling two neighboring vertices, or a burst affecting a whole branch) violate independence and could defeat the weight counting on which $P_{\mathrm{pass}}$ rests. (ii) Amplitude damping is not modeled; on a tree geometry its asymmetric action may or may not respect the nesting structure, and this is unresolved. (iii) The active-baseline comparison rests on assumptions (A1)–(A4), in particular the pessimistic choice $\varepsilon_m = \varepsilon$ and the crude combination rule of (A3); a real baseline may have much smaller $\varepsilon_m$, which would shrink the $\approx 4.08$ factor toward $1$, or repeated measurement rounds per epoch, which would grow it. The comparison is therefore indicative, not apples-to-apples. (iv) The pseudo-threshold $\approx 0.3245$ uses only the dominant term of $P_{\mathrm{pass}}(\varepsilon)$; near $\varepsilon \approx 0.32$ the neglected higher-order terms are not negligible, so the true threshold may differ.

Falsification criteria. The central claims would be falsified if: (a) an explicit encoder on $B_t(v_0)$ fails the Knill–Laflamme conditions for some weight-$\leq t$ Weyl error set, contradicting Proposition 1; (b) two distinct equal-radius balls of $T_{p+1}$ overlap without coinciding, contradicting Lemma 1; or (c) a fault-tolerant simulation of the code under the stated noise model yields logical failure rates inconsistent with the binomial computation of Section 4.3.

Open questions. Whether the ball codes embed into the operator-algebra QEC framework [8], which would allow existing subsystem-code machinery to analyze them; whether Hecke-operator gates admit a fault-tolerant compilation compatible with the code symmetry; and whether the passive advantage survives system-level energy metrics of the kind used in qudit benchmarking [10].

#7. Conclusion

We have formalized a passive quantum error correction scheme in which logical qudits live on balls of the Bruhat–Tits tree $T_{p+1}$, proved a nesting lemma implying that equal-radius balls are nested or disjoint, derived the exact code parameters $n_t = 1 + (p+1)(p^t-1)/(p-1)$ and the conditional distance $d = 2t+1$, and computed analytically that under independent depolarizing noise at $\varepsilon = 10^{-3}$ the flagship $p=3$, $t=1$ block fails with probability $\approx 9.98 \times 10^{-6}$ per epoch, a suppression of $\approx 100.2$ over an unencoded qudit and, as an explicitly labeled projection under stated assumptions, a factor $\approx 4.08$ over an active distance-3 baseline with noisy syndrome extraction. The scheme's promise is real but conditional on constructing an explicit symmetric encoder; we have stated the assumptions, the failure modes, and the falsification criteria plainly so that the proposal can be tested rather than taken on trust.

#References

[1] Continuous-time quantum error correction. arXiv:1311.2485v2. https://arxiv.org/abs/1311.2485v2 [2] Entanglement-Assisted Quantum Error-Correcting Codes. arXiv:1610.04013v1. https://arxiv.org/abs/1610.04013v1 [3] Efficient realization of quantum algorithms with qudits. arXiv:2111.04384v3. https://arxiv.org/abs/2111.04384v3 [4] An Introduction to Error-Correcting Codes: From Classical to Quantum. arXiv:quant-ph/0602157v1. https://arxiv.org/abs/quant-ph/0602157v1 [5] Quantum Computing and Error Correction. arXiv:quant-ph/0304016v2. https://arxiv.org/abs/quant-ph/0304016v2 [6] Quantum error correction beyond qubits. arXiv:0811.3734v1. https://arxiv.org/abs/0811.3734v1 [7] Quantum Error Correction. arXiv:1910.03672v1. https://arxiv.org/abs/1910.03672v1 [8] Stabilizer Formalism for Operator Algebra Quantum Error Correction. arXiv:2304.11442v2. https://arxiv.org/abs/2304.11442v2 [9] QNFO: Alpha Pi Project [10] QNFO: The Qudit Advantage: System-Level Joules-per-Solution Comparison of a Qudit Architecture Against 17 Conventional Qubit Quantum Computing Platforms [11] QNFO: The Ultrametric Foundation: A Unified Thesis on Number, Time, Knowledge, and Computation [12] QNFO: Ultrametric Quantum Gravity and Computation