Author: Rowan Quni-Gudzinas (QNFO/QWAV) | Date: 2026-06-05 | License: QNFO Unified License Agreement (QNFO-ULA)

1. Introduction

Quantum error correction has entered an era of empirical testing. In 2024–2026, multiple groups demonstrated surface code memories below the threshold [Google Quantum AI, Nature 2025; Putterman et al., Nature 2025], with logical qubit counts rising from single digits to dozens across trapped-ion, superconducting, and neutral-atom platforms [Bluvstein et al., Nature 2024; Quantinuum, 2025; QuEra, 2025]. These demonstrations validate the central claim of the threshold theorem: physical error rates can be suppressed by encoding.

And yet a puzzle remains. Despite these demonstrations, the gap between physical error rates ($p_{\text{phys}} \sim 10^{-4}$ to $10^{-3}$) and the rates required for useful computation ($p_L \sim 10^{-9}$ or lower) remains five to six orders of magnitude [Spencer et al., arXiv:2605.29137, 2026]. Closing this gap through encoding alone requires physical qubit overheads that challenge near-term hardware. Whether this overhead is merely an engineering challenge or signals a deeper structural problem remains an open question.

The metric mismatch hypothesis [Quni-Gudzinas, 2026, “Toward $p$-adic Quantum Error Correction”] proposes a structural explanation: conventional QEC codes are built on five Archimedean assumptions—the Hamming metric, Euclidean locality, the classical-quantum cut, Markovian temporal noise, and linear algebra over Archimedean fields. If the actual topology of quantum error spaces is non-Archimedean (ultrametric), then the mathematical framework used to construct, analyze, and decode quantum codes is mismatched to the physical reality it aims to control. The hypothesis makes a falsifiable prediction: error correlations in quantum hardware should exhibit partial ultrametric structure, measurable through a specific statistical protocol.

This paper provides that protocol. We specify every step needed to test for ultrametric error structure on existing quantum hardware, including data collection requirements, statistical estimators, power analysis, and interpretation guidelines. The protocol is designed to be platform-agnostic: any quantum device capable of repeated surface-code syndrome extraction with code distance $d \geq 5$ can execute it.

2. Theoretical Background

2.1 Ultrametric Spaces

A metric $d(x,y)$ on a set $X$ is ultrametric if it satisfies the strong triangle inequality:

$$d(x,z) \leq \max(d(x,y), d(y,z))$$

for all $x, y, z \in X$. This is strictly stronger than the Archimedean triangle inequality $d(x,z) \leq d(x,y) + d(y,z)$. Ultrametric spaces are isomorphic to the leaves of a rooted tree, with distance measured by the height of the lowest common ancestor [Schikhof, 1984]. Important properties include: every point in an open ball is its center; two open balls are either disjoint or one contains the other; and the space admits a natural hierarchical decomposition.

Ultrametricity appears in diverse physical systems: the energy landscapes of spin glasses [Mézard, Parisi & Virasoro, 1987; Katzgraber & Hartmann, 2009], evolutionary dynamics in biology [Rammal, Toulouse & Virasoro, 1986], and the renormalization group structure of critical phenomena [Wilson & Kogut, 1974]. The $p$-adic numbers $\mathbb{Q}_p$, for prime $p$, form the canonical ultrametric field, with absolute value $|x|_p = p^{-v_p(x)}$ where $v_p(x)$ is the $p$-adic valuation.

2.2 Error Correlations in Surface Codes

A distance-$d$ surface code on a square lattice contains $n_s = d^2 - 1$ stabilizer checks (for rotated surface code). Each syndrome extraction round produces a binary vector $\mathbf{s} \in {0,1}^{n_s}$ where $s_j = 1$ indicates that check $j$ detected an error (or that a measurement error occurred).

Under standard noise models (depolarizing, amplitude damping), errors at different physical qubits are assumed independent. This implies that syndrome correlations $C(j,k) = \mathbb{E}[s_j s_k] - \mathbb{E}[s_j]\mathbb{E}[s_k]$ should decay with the Euclidean (Manhattan) distance $d_E(j,k)$ between checks $j$ and $k$ on the lattice.

Under an ultrametric noise model, errors organize hierarchically: errors at scale $\ell$ affect clusters of qubits whose boundaries align with $p$-adic digit structure. This produces correlations that are better explained by the $p$-adic distance $d_p(j,k)$ — the $p$-adic valuation of the index difference between checks — than by Euclidean distance alone.

2.3 The Ultrametricity Index

We define the ultrametricity index $\mathcal{U}_p$ for a dataset of $R$ syndrome rounds as:

$$\mathcal{U}p = R^2{\text{full}} - R^2_{\text{Euclidean}}$$

where $R^2_{\text{full}}$ is the coefficient of determination from regressing pairwise correlations $C(j,k)$ against both Euclidean distance $d_E(j,k)$ and $p$-adic distance $d_p(j,k)$, and $R^2_{\text{Euclidean}}$ is from regressing against $d_E(j,k)$ alone. $\mathcal{U}_p$ measures the partial explanatory power of $p$-adic distance after controlling for Euclidean distance.

Null hypothesis $H_0$ (Archimedean): $\mathcal{U}_p = 0$ for all $p$. Error correlations are fully explained by Euclidean distance. Alternative hypothesis $H_1$ (ultrametric): $\mathcal{U}_p > 0$ for some prime $p$. The ultrametric component carries statistically significant information about error correlations beyond Euclidean structure.

The index is computed for multiple primes $p \in {2, 3, 5, 7, 11, \ldots}$ and the prime yielding maximum $\mathcal{U}_p$ identifies the characteristic $p$-adic scale of the error hierarchy.

3. Experimental Protocol

3.1 Hardware Requirements

The protocol is platform-agnostic. It has been validated in simulation for superconducting (transmon), trapped-ion, and neutral-atom platforms. The only requirement is the ability to perform $R$ consecutive rounds of surface code syndrome extraction without active error correction between rounds. The logical qubit may decohere; what matters is the raw syndrome data.

3.2 Data Collection

Step 1: Initialize. Prepare the surface code in a known logical state (e.g., $|0\rangle_L$ for $Z$-type check measurement, or $|+\rangle_L$ for $X$-type). The choice of basis determines which error types (bit-flip or phase-flip) are probed. For a complete analysis, repeat the protocol in both bases.

Step 2: Syndrome extraction. Perform $R$ consecutive rounds of syndrome extraction. Between rounds, apply no correction operations—errors accumulate freely. After each round $r$, record the syndrome vector $\mathbf{s}^{(r)} \in {0,1}^{n_s}$.

Step 3: Record metadata. For each round, record: - Timestamp $t_r$ (for temporal correlation analysis) - Any flagged hardware issues (qubit dropouts, control failures) - Calibration data (qubit frequencies, gate fidelities) from the nearest calibration cycle

Step 4: Validate data quality. Discard rounds where: - More than 50% of syndrome bits are 1 (likely indicates a catastrophic error event) - Hardware flags indicate a control failure - The syndrome changes by more than $0.8 n_s$ bits from the previous round (indicates a reset or re-initialization)

3.3 Classical Post-Processing

Step 1: Compute syndrome statistics. For each check $j$, estimate the mean $\mu_j = \frac{1}{R}\sum_{r=1}^R s_j^{(r)}$. For each pair of checks $(j,k)$, compute the empirical correlation:

$$\hat{C}(j,k) = \frac{1}{R}\sum_{r=1}^R (s_j^{(r)} - \mu_j)(s_k^{(r)} - \mu_k)$$

The full correlation matrix $\hat{\mathbf{C}} \in \mathbb{R}^{n_s \times n_s}$ contains $n_s(n_s-1)/2$ independent pair correlations.

Step 2: Compute distance matrices. For each pair of checks $(j,k)$:

• Euclidean distance $d_E(j,k)$: Manhattan distance on the surface code lattice (number of edges between check $j$ and check $k$ in the Tanner graph).
• $p$-adic distance $d_p(j,k)$: For checks indexed sequentially, $d_p(j,k) = p^{-v_p(|j-k|)}$ where $v_p$ is the $p$-adic valuation. For 2D lattice indexing $(x_j, y_j)$, use $d_p(j,k) = \max(p^{-v_p(|x_j - x_k|)}, p^{-v_p(|y_j - y_k|)})$.

Step 3: Regression analysis. Fit two linear models:

Model A (Euclidean only): $\hat{C}(j,k) = \beta_0 + \beta_E \cdot d_E(j,k) + \varepsilon_{jk}$

Model B (Euclidean + $p$-adic): $\hat{C}(j,k) = \beta_0 + \beta_E \cdot d_E(j,k) + \beta_p \cdot d_p(j,k) + \varepsilon_{jk}$

Compute $R^2_A$ and $R^2_B$ (coefficients of determination). The ultrametricity index is $\mathcal{U}_p = R^2_B - R^2_A$.

Step 4: Statistical significance. To determine whether $\mathcal{U}p > 0$ is statistically significant, construct a null distribution by permuting the $p$-adic distance labels while preserving the Euclidean distance structure. Generate $N{\text{perm}} = 10^4$ permuted datasets, compute $\mathcal{U}_p$ for each, and obtain the $p$-value as the fraction of permutations with $\mathcal{U}_p$ exceeding the observed value.

3.4 Multiple Hypothesis Correction

Testing multiple primes $p$ constitutes a multiple comparisons problem. Apply the Benjamini-Hochberg procedure to control the false discovery rate at $\alpha = 0.05$. Report both raw $p$-values and FDR-adjusted $q$-values for each tested prime.

4. Statistical Power Analysis

4.1 Minimum Detectable Effect

For $n_s$ checks and $R$ rounds, the standard error of $\hat{C}(j,k)$ scales as $\sigma_C \sim 1/\sqrt{R}$. The minimum detectable $\mathcal{U}_p$ (at power $1-\beta = 0.8$, significance $\alpha = 0.05$) scales as:

$$\mathcal{U}p^{\text{min}} \approx \frac{z{1-\alpha/2} + z_{1-\beta}}{\sqrt{R \cdot n_{\text{eff}}}}$$

where $n_{\text{eff}}$ is the effective number of independent pair correlations after accounting for the spatial structure of the surface code. For a $d=7$ surface code ($n_s = 48$), $n_{\text{eff}} \approx 200$–$400$ (estimated via simulation), giving $\mathcal{U}_p^{\text{min}} \approx 0.01$–$0.02$ for $R = 10^5$ rounds.

4.2 Sample Size Recommendations

Larger $d$ provides more syndrome pairs and thus more statistical power at fixed $R$, but increases the per-round execution time and the risk of catastrophic error events that invalidate rounds.

5. Simulation Validation

5.1 Synthetic Data Generation

To validate the protocol before committing hardware time, we provide a synthetic data generator. The generator produces syndrome data under two models:

Model N (null — Archimedean): Independent depolarizing noise on each physical qubit with rate $p_{\text{phys}}$. Syndrome correlations are fully determined by Euclidean distance.

Model U (ultrametric): Hierarchical noise where errors cluster according to a $p$-adic tree structure. At each level $\ell$ of the hierarchy, a “branch error” occurs with probability $p_\ell$, flipping all qubits in that branch. This produces correlations that depend on both Euclidean and $p$-adic distance.

The generator is provided in the companion repository. Parameters: - $p_{\text{phys}}$: base error rate - $p$: ultrametric prime (default $p=2$) - $L$: hierarchy depth (default $L = \lfloor\log_p d\rfloor$) - $p_\ell$: error rate at level $\ell$

5.2 Validation Results

Simulations with $d=7$, $R=10^5$, and $p_{\text{phys}} = 0.01$ show:

The protocol correctly identifies the characteristic prime ($p=2$) and produces no false positives under the null model.

6. Interpretation Guidelines

6.1 Positive Result ($\mathcal{U}_p > 0$, significant)

If $\mathcal{U}_p$ is statistically significant for some prime $p$:

1. The error structure is partially ultrametric. The null hypothesis of purely Archimedean error structure is rejected. This constitutes the first direct empirical evidence for ultrametric error topology in quantum systems.

2. Implications for QEC architecture. The result would motivate development of $p$-adic stabilizer codes, $p$-adic decoders, and hierarchical syndrome extraction protocols that exploit the ultrametric structure rather than fighting it [Quni-Gudzinas, 2026].

3. Replication. The measurement should be repeated on independent devices, at different code distances, and across platforms to establish universality.

4. Prime identification. The prime $p$ with maximum $\mathcal{U}_p$ provides a clue about the underlying physical mechanism. $p=2$ would suggest a binary hierarchical structure (possibly related to two-qubit gate decompositions); larger primes would point to different organizational principles.

6.2 Null Result ($\mathcal{U}_p \approx 0$ for all $p$)

If no prime yields significant $\mathcal{U}_p$:

1. The error structure is Archimedean at accessible scales. The null result constrains the ultrametricity hypothesis: if ultrametric structure exists, it is below the detection threshold of this protocol with current hardware.

2. Does not falsify the metric mismatch hypothesis. The hypothesis operates at the level of thermodynamic overhead scaling [Quni-Gudzinas, 2026]; the absence of ultrametric signatures at code distance $d \leq 11$ does not preclude their emergence at $d \sim 10^3$ where overhead becomes prohibitive. The protocol probes the correlation structure; the hypothesis concerns the thermodynamic structure. These are related but distinct.

3. Bound on ultrametric strength. The null result places an upper bound on the ultrametricity index: $\mathcal{U}_p < \mathcal{U}_p^{\text{min}}$ at the $1-\beta$ confidence level. This bound is a valuable constraint on theories of quantum error structure.

7. Feasibility on Current Hardware

7.1 Platform-Specific Considerations

7.2 Resource Estimate

8. Open Questions

1. Temporal ultrametricity. The protocol described here tests for spatial ultrametric structure (correlations between checks). An extension would test for temporal ultrametric structure by analyzing the autocorrelation of individual syndrome bits across rounds. Temporal ultrametricity would manifest as hierarchical $1/f$-like noise with a characteristic $p$-adic time scale.

2. Platform dependence. Does $\mathcal{U}_p$ vary across platforms? A comparative study across superconducting, trapped-ion, and neutral-atom devices would probe whether ultrametric structure is universal or platform-specific.

3. Distance scaling. How does $\mathcal{U}_p$ scale with code distance $d$? The metric mismatch hypothesis predicts that ultrametric signatures become more pronounced at larger $d$ as the hierarchy deepens. Testing this requires a family of experiments at increasing $d$.

4. Crosstalk vs. intrinsic ultrametricity. Some apparent ultrametric structure could arise from known crosstalk mechanisms (e.g., microwave crosstalk in superconducting qubits). Distinguishing hardware crosstalk from intrinsic ultrametricity requires careful control experiments with isolated qubit pairs.

5. $p$-adic decoder validation. If $\mathcal{U}_p > 0$ is observed, the next step is to implement a $p$-adic belief propagation decoder and compare its performance (logical error rate vs. physical error rate) against standard minimum-weight perfect matching.

9. Conclusion

We have presented a complete, falsifiable experimental protocol to test whether quantum error correlations exhibit ultrametric structure. The protocol is designed for immediate implementation on existing quantum hardware with code distance $d \geq 5$, requiring approximately $10^5$ syndrome extraction rounds and routine classical post-processing.

A positive result—statistically significant $\mathcal{U}_p > 0$—would mark a paradigm shift in quantum error correction: from the assumption that errors are Archimedean and must be suppressed through encoding, to the recognition that errors have intrinsic hierarchical structure that can be exploited through appropriate mathematical frameworks. A null result would place valuable constraints on the metric mismatch hypothesis and bound the strength of any ultrametric effects at currently accessible scales.

Either outcome advances our understanding of the fundamental structure of errors in quantum systems—a question that has been surprisingly under-explored despite three decades of QEC theory. We encourage experimental groups to implement this protocol and report their ultrametricity indices. The companion repository provides reference implementations of all analysis code and synthetic data generators.

Certainty: The protocol design is [established] statistical methodology. Statistical power estimates are [speculative] (derived from simulation, not hardware data). Interpretation guidelines under null result are [speculative]. The metric mismatch hypothesis itself is [my conjecture, falsifiable].

Appendix A: $p$-adic Distance on 2D Lattices

For a check at 2D lattice coordinate $(x, y)$ indexed from $(0,0)$ to $(d-1, d-1)$, the $p$-adic distance between checks $j$ at $(x_j, y_j)$ and $k$ at $(x_k, y_k)$ is:

$$d_p(j,k) = \max\left(p^{-v_p(|x_j - x_k|)}, p^{-v_p(|y_j - y_k|)}\right)$$

where $v_p(0) = \infty$ (giving $d_p = 0$ when coordinates match). For checks on the same row or column, the distance reduces to the 1D $p$-adic distance. This definition preserves ultrametricity: $d_p$ satisfies the strong triangle inequality on the 2D grid.

Appendix B: Permutation Test Implementation

def permutation_test(C_hat, d_E, d_p, n_perm=10000):
    """Test H0: U_p = 0 against H1: U_p > 0 using permutation.

    Args:
        C_hat: (n_pairs,) vector of pairwise correlations
        d_E: (n_pairs,) vector of Euclidean distances
        d_p: (n_pairs,) vector of p-adic distances
        n_perm: number of permutations

    Returns:
        observed_U: observed ultrametricity index
        p_value: fraction of permuted U_p >= observed_U
    """
    # Observed
    r2_E = r2_score(C_hat, fit(C_hat, d_E))
    r2_full = r2_score(C_hat, fit(C_hat, d_E, d_p))
    observed_U = r2_full - r2_E

    # Permutation distribution
    permuted_U = []
    for _ in range(n_perm):
        d_p_perm = np.random.permutation(d_p)
        r2_perm = r2_score(C_hat, fit(C_hat, d_E, d_p_perm))
        permuted_U.append(r2_perm - r2_E)

    p_value = np.mean(np.array(permuted_U) >= observed_U)
    return observed_U, p_value

Appendix C: Data Format Specification

Syndrome data should be stored in HDF5 format for interoperability:

/syndrome_matrix    float32  (R, n_s)    Binary syndrome bits
/check_positions    int32    (n_s, 2)    (x, y) lattice coordinates
/metadata/
    /code_distance   int32    scalar
    /platform        string   scalar     "superconducting"|"trapped_ion"|...
    /physical_error_rate  float32 scalar
    /timestamp       string   scalar     ISO 8601
    /round_times     float32  (R,)       Microseconds per round