A Different Geometry for Computing

title: A Different Geometry for Computing

date: 2026-05-08

author: "Rowan Brad Quni-Gudzinas"

ORCID: "0009-0002-4317-5604"

ISNI: "0000000526456062"

status: "Publication Draft — Version 0.8"

aliases:

- A Different Geometry for Computing

- Ultrametric Quantum Computing

- Bruhat-Tits Tree Computing

- QWAV Architecture

- Passive Geometric Error Correction

- p-Adic Quantum Computing

modified: 2026-05-08T18:31:29Z

Why Six Independent Lines of Evidence Converge

Author: Rowan Brad Quni-Gudzinas

Contact: [email protected]

ORCID: 0009-0002-4317-5604

ISNI: 0000000526456062

DOI: 10.5281/zenodo.20089407

Date: 2026-05-08

Version: 0.8

WHO THIS IS FOR

This document assumes you are intelligent and educated—a mathematician, an electrical engineer, a chemist, a software developer, or anyone comfortable with logical reasoning—but that you have never studied quantum computing. Every idea is explained from the ground up. Every term is defined before it is used. No prior knowledge of physics, number theory, or any specialized field is assumed.

If a sentence would not make sense to someone who has never taken a quantum mechanics course, that sentence has been revised or removed.

HOW TO READ THIS DOCUMENT

• Parts 1–4 explain the scientific content: the problem, the alternative geometry, the six lines of converging evidence, and the synthesis.
• Part 5 enumerates what remains unknown—the open questions that define the path forward.
• Part 6 is the conclusion.
• Appendices A–C provide the formal evidence base: publication inventory, claims evidence matrix, and theorem catalog.

1.1 What Makes a Computer “Quantum”

A regular computer stores information in bits. A bit is a switch: it is either ON or OFF. There is nothing in between. Every computation—every spreadsheet, every video game, every web page—is built from these ON/OFF switches, billions of them, flipping in sequence.

A quantum computer stores information differently. To understand how, think geometrically.

Imagine a compass needle. It can point north. It can point south. But it can also point northeast, or east-southeast, or any direction on the compass rose. The needle’s state is not simply “north or south”—it is a specific direction, a point on a circle.

A quantum bit—a qubit—is analogous, but its state space is not a circle. It is the surface of a sphere. Every point on the sphere corresponds to a distinct physical state the qubit can occupy. The north pole represents one classical bit value (say, OFF). The south pole represents the other (ON). But the qubit is not confined to the poles. It can occupy any point on the sphere.

This sphere is called the Bloch sphere, after the physicist Felix Bloch. A qubit’s state is fully described by two angles—its latitude and longitude on the sphere—just as a point on Earth is described by its coordinates. The state is a definite geometric point. It is not a cloud of probabilities. It does not “hold both possibilities at once”—it occupies one position on the sphere, and that position determines the outcome of any subsequent operation.

The power of quantum computing comes from the geometry of operations. A quantum gate is a rotation of the sphere—a precise reorientation that moves the state point from one location to another along a specific geometric path. Multiple qubits combine into a higher-dimensional geometric space, and gates are rotations in that space. The computation is a choreographed sequence of geometric transformations.

A classical computer with $100$ bits can be in exactly one of roughly $10^{30}$ possible ON/OFF combinations at any moment. A quantum computer with $100$ qubits occupies a single point in a geometric space of far greater dimensionality. The gates act on this point—rotating it, reflecting it, entangling its coordinates with those of other qubits—tracing a continuous geometric path through the state space. The computation explores this geometry.

When the computation is complete, the qubits must be read out. The readout projects each qubit’s state onto the north-south axis—forcing it to one of the two poles. A state in the northern hemisphere reads as OFF; a state in the southern hemisphere reads as ON. The readout is a geometric projection, and it is the only step that discards information—it collapses the continuous spherical position into a binary answer.

This sounds like magic. It is not. It is a physical property of very small, very cold, very isolated systems. And it comes with a severe problem.

1.2 Why Quantum Bits Are Fragile

A qubit’s geometric state is exquisitely delicate. Consider all the things that can disturb it:

• An electromagnetic field can rotate the state slightly—a fraction of a degree off its intended orientation.
• A thermal vibration in the material can jostle the state, introducing a small random rotation.
• An imperfection in the crystal lattice can tilt the local energy landscape, biasing the state toward the wrong direction.
• Even the control pulses themselves—generated by imperfect electronics—apply slightly the wrong rotation, accumulating error with every gate.

For a real quantum bit, the disturbances are even more varied:

• Thermal vibrations: Atoms in the material are always jiggling. At room temperature, this jiggling is violent. Even near absolute zero, there is residual motion.
• Electromagnetic noise: Every electronic device, every radio station, every cosmic ray produces electromagnetic fields that can couple to the qubit.
• Material imperfections: No crystal is perfect. Variations in the atomic lattice create local electric and magnetic fields that differ from place to place.
• Control errors: The pulses used to manipulate qubits are generated by imperfect electronics. A pulse meant to be exactly $10$ nanoseconds long might be $10.01$ nanoseconds.

Each of these disturbances is an error. It rotates the qubit’s state slightly away from where it should be. After one operation, the error might be tiny—a $0.1\%$ deviation. After one hundred operations, the accumulated error might be $10\%$. After one million operations, the computation is meaningless noise.

The central challenge of quantum computing is not building qubits. It is keeping them accurate long enough to complete a computation. This is the error correction problem.

1.3 The Current Fix: Active Error Correction

Imagine writing a sentence on a whiteboard while someone stands beside you, watching every letter you write, erasing every smudge the instant it appears. That is active error correction.

In quantum computing, you cannot simply look at the qubit to check if it has an error—measuring directly collapses the state, destroying the computation. The trick is to look indirectly. You encode each logical bit of information across multiple physical bits. You measure relationships between them—not their individual values. From these relationships, you can deduce whether an error occurred and where, without learning the information itself, and therefore without collapsing the state.

The leading protocol is the surface code. It works roughly like this:

1. Arrange physical qubits on a two-dimensional grid.

1. Designate some as “data qubits” (they hold the information) and others as “measurement qubits” (they check for errors).

1. Repeatedly—millions of times per second—measure groups of measurement qubits. Each measurement checks whether the surrounding data qubits have flipped relative to each other.

1. Feed the measurement results to a classical computer that runs a decoding algorithm—a program that identifies the most likely pattern of errors given the measurement history.

1. Apply correction pulses to flip back any qubits that the decoder identifies as erroneous.

This works. It has been demonstrated in small systems. The surface code can take a physical error rate of $0.1\%$ per operation and produce a logical error rate of one in a billion billion—sufficient for useful computation.

But it comes with a hidden cost.

1.4 The Thermodynamic Wall

Every measurement consumes energy. Every correction pulse consumes energy. Every signal sent from the room-temperature control electronics down to the near-absolute-zero processor dissipates heat along the way. All of this heat must be removed by a cooling system.

The cooling system is a dilution refrigerator—a device that uses a mixture of helium-3 and helium-4 isotopes to reach temperatures of roughly $0.01$ degrees above absolute zero. These refrigerators are engineering marvels, but they have a hard physical limit: they can remove about $10$ millionths of a watt of heat while maintaining the base temperature.

Let us walk through the numbers.

A single qubit measurement in a surface code processor generates roughly $10$ attojoules of heat at the processor—that is $10^{-17}$ joules. This seems tiny. But you need many measurements. A useful quantum computer might require:

• $10{,}000$ logical qubits (to run algorithms that matter—factoring large numbers, simulating molecules)
• $1{,}000$ physical qubits per logical qubit (surface code overhead) $= 10$ million physical qubits
• $1$ million measurement cycles per second per logical qubit (to catch errors before they spread)
• Each measurement cycle involves reading about $10$ measurement qubits per logical qubit

Total measurements per second: $10{,}000 \times 1{,}000{,}000 \times 10 = 100$ billion measurements per second.

Total heat generated at the processor: $100$ billion $\times 10$ attojoules $= 1$ watt.

The refrigerator can handle $10$ microwatts—$0.00001$ watts.

The heat load exceeds the cooling capacity by a factor of $100{,}000$.

This is the thermodynamic wall. It is not an engineering problem that gets easier with better refrigerators. The second law of thermodynamics sets a fundamental lower bound on the energy cost of erasing information. Active error correction erases vast amounts of information—every measurement result must be processed and discarded, and the erasure generates heat proportional to the number of bits erased times the temperature. At scale, the numbers simply do not work.

1.5 The Hidden Assumption

There is an assumption buried so deep in this entire picture that almost no one questions it. It concerns geometry—specifically, what it means for two states to be “close” to each other.

In the geometry we all learned in school, distances work like this: if you walk one meter east, then one meter north, you are about $1.4$ meters from where you started. Two small steps added up to a larger step. A thousand one-millimeter steps add up to a meter. Small things can accumulate into big things.

The Bloch-sphere picture of a quantum bit inherits this Archimedean geometry. The state of a qubit is a point on the surface of a sphere. Errors are small rotations of that point—tiny displacements away from the intended position. After one displacement, the point has moved slightly. After many displacements, the point can be anywhere on the sphere. The information is lost.

This property has a name: the Archimedean property. It is named after Archimedes, the ancient Greek mathematician, who observed that given any small distance and any large distance, you can eventually cover the large one by taking enough copies of the small one. A grain of sand, multiplied enough times, can fill the universe.

The surface code fights this by constantly measuring and correcting. But the underlying geometry—the fact that errors can accumulate at all—is the reason active correction is needed in the first place.

What if there were a different geometry? One where small steps simply cannot add up to a big step? One where a thousand one-millimeter errors cannot combine into a meter-sized error?

In such a geometry, errors would be geometrically forbidden from accumulating. No measurement would be needed. No correction pulses. No heat. The geometry itself would provide the protection.

This document is about that alternative geometry. It explains why the geometry exists, how it emerges naturally from a different way of measuring distance, and why six independent lines of research—pursued by different communities for entirely different reasons—all point toward the same geometric object as the natural home for this alternative approach to computing.

2.1 Two Ways to Ask “How Big Is This Number?”

Consider the number $16$.

The ordinary way to measure size: $16$ is sixteen units from zero. It is larger than $8$, larger than $4$, larger than $3$. The ordinary absolute value of $16$ is $16$.

Now consider a different question: how many times can you divide $16$ by $2$ before you get an odd number?

• $16 \div 2 = 8$
• $8 \div 2 = 4$
• $4 \div 2 = 2$
• $2 \div 2 = 1$ (odd—stop)

Answer: four times. We can say that $16$ has “2-ness” equal to $4$, or that its “size measured by $2$” is $1/16$—the reciprocal of $2$ raised to the fourth power.

Let us try another number: $3$. How many times can you divide $3$ by $2$ before you get a non-integer? Zero times. $3$ is not divisible by $2$ at all. Its “size measured by $2$” is $1$—no suppression.

Now compare: by the ordinary measure, $16$ is larger than $3$. By the 2-measure, $16$ (size $= 1/16$) is much smaller than $3$ (size $= 1$). A number that is highly divisible by $2$ is considered small, no matter how large it is in the ordinary sense.

Let us try one more: $1{,}024$. This is $2$ to the tenth power. By the ordinary measure, it is over a thousand—quite large. By the 2-measure, its size is $1/1024$—very small. The number $3$, which is not divisible by $2$ at all, is considered larger than $1{,}024$ by this alternative measure.

This is not a trick or a metaphor. It is a legitimate, rigorous mathematical system. For every prime number—$2, 3, 5, 7, 11, 13$, and so on through all the infinite primes—there is a corresponding way of measuring size. The formal name for these measures is $p$-adic absolute values, where $p$ stands for the chosen prime. For a rational number $x = p^n \cdot (a/b)$ where $a$ and $b$ are not divisible by $p$, the $p$-adic absolute value is:

The $p$-adic measures were developed in the late nineteenth and early twentieth centuries by Kurt Hensel. They are not a fringe curiosity. Ostrowski’s theorem, proved in 1916, establishes that the only nontrivial ways to measure size on the rational numbers—fractions of whole numbers—are the ordinary absolute value and the $p$-adic absolute values. They are exhaustive. If you want to measure the size of numbers in a way that respects addition and multiplication, you have exactly these choices.

The completion of $\mathbb{Q}$ with respect to $|\cdot|_p$ is the field $\mathbb{Q}_p$ of $p$-adic numbers. These are not “alternative” numbers—they are as mathematically legitimate as the reals.

2.2 The Triangle Inequality, Strengthened

In ordinary geometry, distances obey the triangle inequality: the distance from point $A$ to point $C$ is at most the distance from $A$ to $B$ plus the distance from $B$ to $C$.

    B
   / \
  /   \
 A-----C

The path $A \to B \to C$ cannot be shorter than the direct path $A \to C$, but it can be longer. Take the long way around, and the distances add up.

The $p$-adic measure satisfies a stronger version:

This is the strong triangle inequality (also called the ultrametric inequality). The distance from $A$ to $C$ is at most the larger of the two individual distances—not their sum, but their maximum.

Its consequence is profound: two “small” distances can never add up to a “large” distance. The sum can never exceed the larger of the two parts.

In practical terms: if you make two small errors—two small deviations from the intended path—the combined effect is at most the larger of the two errors. The errors do not accumulate. A thousand small errors still produce at most the single largest error among them. The worst-case error is bounded by the worst single error, not by the sum of all errors.

This is the entire key. In an ordinary (Archimedean) geometry, errors accumulate—the thousandth error adds to the $999$ that came before. In a $p$-adic (ultrametric) geometry, errors do not accumulate—each new error simply replaces the previous maximum, which remains bounded.

2.3 The Shape That Emerges: The Bruhat–Tits Tree

When you take all the $p$-adic numbers and organize them according to which ones are close to each other—using the $p$-adic distance—they naturally form a tree.

Here is why. Two numbers are $p$-adically close if their difference is highly divisible by $p$. The more divisible, the closer they are. This creates a hierarchical structure: numbers that are close at the finest level are also close at all coarser levels. Numbers that belong to the same “branch” at one level remain in the same branch at all higher levels.

Imagine a family tree. You have parents, grandparents, great-grandparents. The distance between you and your sibling is $2$: up to your parent, down to your sibling. The distance between you and your first cousin is $4$: up to your parent, up to your grandparent, down to your aunt or uncle, down to your cousin. The distance between you and a stranger is large—you must go up many generations before finding a common ancestor.

The $p$-adic tree is like this, but infinite in all directions. Each point on the tree has exactly $p+1$ connections to neighboring points: one connection going “up” toward the root direction, and $p$ connections going “down” toward the leaves. For the prime $2$, each point has three connections. For the prime $3$, each point has four connections. For the prime $5$, each point has six connections.

This shape is called the Bruhat–Tits tree $T_p$, after the French mathematician François Bruhat and the Belgian mathematician Jacques Tits, who characterized its properties in the 1960s and 1970s.

The tree distance $d(u, v)$ between two vertices counts the number of edges on the unique path connecting them. Crucially, this distance satisfies the ultrametric inequality:

The tree inherits the strong triangle inequality from the $p$-adic measure. On the tree, if you move from point $A$ to a neighboring point $B$ (distance $1$), then to a neighboring point $C$ (distance $1$ from $B$), your total distance from $A$ is at most the larger of the two steps—which is $1$. You cannot wander far by taking small steps.

The boundary at infinity of the tree is $\mathbb{P}^1(\mathbb{Q}_p)$, the $p$-adic projective line. The group $\operatorname{GL}(2, \mathbb{Q}_p)$—the set of all $2 \times 2$ invertible matrices with entries in the $p$-adic numbers—acts naturally on the tree as isometries (distance-preserving transformations). This group of symmetries will turn out to be central to everything that follows.

2.4 Using the Tree as a Computer’s State Space

A computer—quantum or classical—needs a set of possible states it can be in. These are the “positions” where information is stored.

For a classical computer, the state space is the set of all combinations of ON and OFF bits. For $100$ bits, there are $2^{100}$ possible states—an astronomically large number, but discrete and well-defined.

For a standard quantum computer, the state space is typically the surface of a sphere—the Bloch sphere. This is a continuous space. Errors are small continuous rotations away from the intended point.

Now consider a different choice: let the possible states be the points on the $p$-adic tree. Not a continuous sphere, but a discrete tree where each point is a distinct, identifiable location.

A computation is a journey from one point on the tree to another, following a prescribed path. An error is an unintended step to a neighboring point.

Because of the strong triangle inequality, these unintended steps cannot accumulate. If your program intends to take you from point $A$ deep in the tree to point $Z$ on a different branch, and along the way you make several small unintended steps, you will at most end up at the largest single unintended step away from your path. You will never accidentally cross to a completely different branch. The geometry guarantees this.

This is geometric protection. The shape of the state space itself prevents certain kinds of failure. The tree’s structure—its branching pattern, its ultrametric distance, its hierarchical organization—makes errors self-limiting. No active monitoring is required. No energy is spent measuring syndromes and applying corrections. The protection is a theorem of the geometry.

2.5 The Ultrametric Hilbert Space

The state space for a quantum system living on the tree is formalized as a Hilbert space—a complex vector space with an inner product, complete in the induced norm:

The basis states are the vertices of the tree. A pure quantum state is a superposition:

The inner product is $\langle u \lvert v \rangle = \delta_{uv}$—orthogonal for distinct vertices. The Hilbert space is infinite-dimensional (the tree has infinitely many vertices), but physical computations are restricted to finite-depth subspaces.

A logical qubit at depth $d$ uses two distinguished vertices $v_0$ and $v_1$ (chosen to be “far apart” on the tree, e.g., in different branches at depth $d$) as the computational basis states. The logical Hilbert space is the two-dimensional subspace spanned by $\lvert v_0 \rangle$ and $\lvert v_1 \rangle$.

Multi-qubit Hilbert space:

Entanglement—Bell states, adelic entanglement across different primes—is all explicitly defined within this framework.

This is a Hilbert space in the standard sense. What makes it different is the geometry of its basis: the tree structure imposes an ultrametric topology on the state space. Two basis states $\lvert u \rangle$ and $\lvert v \rangle$ that are “close” on the tree are in the same ultrametric ball—and errors confined to that ball cannot change the logical information.

The following six sections describe discoveries made by different communities, pursuing different goals, using different methods. None of them set out to build a quantum computer on a tree. Each was investigating its own questions. Yet all six converge on the same geometric object: the tree with the strong triangle inequality.

This convergence—what the nineteenth-century philosopher William Whewell called consilience—is the central argument of this document. When multiple independent lines of evidence point to the same structure, that convergence is itself evidence that the structure is fundamental. It is not one arbitrary choice among many. It is the unique geometric object where these six roads intersect.

3.1 Road One: Why Quantum Mechanics Seems Weird (And Why the Tree Makes It Coherent)

Quantum mechanics has resisted philosophical understanding for a century. The standard presentation—the Copenhagen interpretation—treats measurement as a mysterious “collapse,” probability as fundamental randomness, entanglement as “spooky action at a distance,” and wave-particle duality as an irreducible paradox. These are not solved problems. They are the places where the theory stops making sense.

What if the problem is not quantum mechanics itself, but the geometry we use to describe it?

The Measurement Problem. In the standard picture, a quantum state evolves deterministically according to the Schrödinger equation, then “collapses” probabilistically when measured. No equation describes when or how collapse occurs. This is the measurement problem, and it has spawned a century of interpretations—objective collapse, many-worlds, QBism, Bohmian mechanics—none achieving consensus.

In the ultrametric framework, the measurement problem dissolves. The state is a definite point on the Bruhat–Tits tree (or its boundary). It does not “collapse.” Measurement is the Monna map—a many-to-one geometric projection from the tree boundary onto the real interval $[0,1]$. What appears as collapse is the information loss inherent in the projection. The tree state was always definite. The appearance of resolving multiple possibilities into one is an artifact of measuring a tree-structured reality with an Archimedean ruler.

Probability. In the standard picture, the Born rule—that measurement outcomes occur with probability $|\psi|^2$—is a postulate. Nothing explains it. In the ultrametric framework, probability is geometric counting. The state occupies a vertex at some depth in the tree. The readout projects all descendant branches onto the north-south axis of the Bloch sphere. The proportion of branches that project onto “OFF” versus “ON” is exactly the Born-rule probability. It is not fundamental randomness—it is counting.

Entanglement. In the standard picture, entangled particles exhibit correlations that appear to violate locality—“spooky action at a distance.” In the ultrametric framework, entanglement is shared ancestry. Two particles that share a deep common vertex in the tree exhibit correlations that appear nonlocal only when their states are projected onto the Archimedean Bloch sphere. In the tree geometry, the particles are ultrametrically close—their distance is measured by the depth of their common ancestor, not by their spatial separation. The correlation is a geometric fact about the tree, not a nonlocal influence.

Wave-Particle Duality. In the standard picture, light and matter exhibit both wave-like and particle-like behavior, switching between them depending on how they are measured. In the ultrametric framework, duality is resolution-dependent sampling. At coarse resolution—the Archimedean projection—the tree structure collapses to a point, and behavior appears particle-like. At fine resolution, the branching tree structure becomes visible, and behavior appears wave-like. The “duality” is not a property of nature—it is a property of the resolution at which we interrogate the tree.

The convergence. The same tree geometry that geometrically prevents error accumulation (Parts 1–2) also dissolves the century-old philosophical problems of quantum mechanics. This is not a coincidence. The tree is not merely a clever state space for error-protected computing—it is the natural geometry in which quantum mechanics becomes coherent. The Copenhagen interpretation is not wrong—it is a low-resolution description of a tree-structured reality, projected onto an Archimedean screen.

A cautionary note on anyons. Anyon-based topological quantum computing pursued a similar geometric-protection intuition but within Archimedean spacetime. The braid-solenoid isomorphism—a functorial correspondence between abelian anyonic braid groups and the $p$-adic solenoid—is mathematically valid. But the physical implementation of anyon braiding has not succeeded: after twenty-five years of effort, no topologically protected qubit has been demonstrated, and thermal fragility limits anyon-based approaches to temperatures far below what is practical. The solenoid is real; the tree is real; the isomorphism between them is real. But the route through anyon braiding was the wrong physical route. The tree does not need anyons. The protection of the tree is geometric (ultrametric), not topological (worldline braiding).

3.2 Road Two: The Energy Rulebook (Hamiltonian Engineering)

Every physical system has a rulebook. For a ball rolling down a hill, the rulebook includes the downward pull of gravity and the shape of the hillside. For an electron in an atom, the rulebook determines which specific energy levels are allowed and how the electron can jump between them.

For any physical system, the rulebook is called the Hamiltonian. Mathematically, it is an operator—a rule that takes a description of the system’s current state and produces a description of how that state will change over time. Think of it as the energy landscape that the system moves through. The valleys are stable states (low energy, the system wants to be there). The hills are energy barriers (the system must be pushed over them to change state). The height of a barrier, divided by the thermal energy available at the system’s temperature, determines how often random thermal motion will accidentally push the system across.

For the tree, there are several natural choices of Hamiltonian—several ways to assign energies to points and transition rules to edges. None of these choices is forced. All of them are natural consequences of the tree’s geometry. Five distinct Hamiltonians all live on the same tree and are governed by the same group of symmetries.

Hamiltonian 1: The Discrete Laplacian

The simplest Hamiltonian on the Bruhat–Tits tree is the discrete Laplacian—the tree analog of a wave equation:

where $J$ is the characteristic energy scale (e.g., the Josephson energy in a superconducting implementation) and the sum runs over all $(p+1)$ neighboring vertices.

Theorem 3.2 (Spectral decomposition). The eigenfunctions are the spherical functions:

where $s \in \mathbb{C}$ is the spectral parameter and $d(v, v_0)$ is the tree distance from the root. The continuous spectrum is:

Theorem 3.3 (Logical energy gap). For a logical qubit encoded at depth $D$:

This is a provable energy gap—a specific number that grows linearly with depth. It directly implies exponential error suppression:

Hamiltonian 2: Tight-Binding

A more general Hamiltonian allows the coupling strength between vertices to depend on their distance:

where $J_{d(u,v)}$ is the hopping amplitude (typically $J_1$ for nearest neighbors, smaller for longer hops) and $\varepsilon_v$ are on-site energies that can vary across the tree.

Hamiltonian 3: Bost–Connes (Prime Numbers)

The most mathematically striking Hamiltonian was discovered in the study of operator algebras and number theory. It assigns energies that are the logarithms of the counting numbers:

The eigenvalues are $\log(n)$, with multiplicities given by the divisor function. The partition function at inverse temperature $\beta$ is the Riemann zeta function:

This connects the tree Hamiltonian directly to the Riemann zeta function and, through it, to the distribution of prime numbers. The fact that a Hamiltonian on the tree naturally encodes the zeta function is not a coincidence—it reflects the deep connection between the tree (which comes from $p$-adic numbers) and prime numbers (which are the primes $p$ in $p$-adic).

Hamiltonian 4: Gate Operations

When you want to perform a specific computation, you apply a time-varying pulse of energy:

where $\Omega(t)$ is a time-dependent Rabi frequency (the strength of the driving field) and the sum couples a parent vertex to its children. By choosing the pulse shape, one implements specific tree isometries—the ultrametric analog of quantum logic gates.

A universal gate set is a collection of basic operations from which any desired computation can be built. For the tree, the basic operations are tree isometries—relabelings of the tree’s points that preserve all distances. These include permuting the branches at a point, cycling the children of a point, and translating a state along a path through the tree.

Hamiltonian 5: Adelic Constraint

There is a tree for each prime number: $T_2, T_3, T_5$, and so on. These trees are not independent. The adelic product formula—a fundamental identity in number theory—links them:

where $\lvert x \rvert_\infty$ is the usual absolute value and the product runs over all primes. This formula links the real numbers and all $p$-adic numbers into a single global constraint.

This constraint can be enforced by a Hamiltonian:

States that violate the product formula acquire a large energy penalty and are dynamically suppressed. Gates that would violate the constraint are energetically forbidden—gapped out by the constraint Hamiltonian. This links the separate trees into a single coherent system—an adelic computer.

The convergence: Five independent Hamiltonians—the discrete Laplacian, the tight-binding model, the Bost–Connes system, the gate Hamiltonian, and the adelic constraint—all live on the same geometric object (the Bruhat–Tits tree) and are governed by the same group of symmetries ($\operatorname{GL}(2, \mathbb{Q}_p)$). They are not competing theories. They are different aspects of the same mathematical structure, viewed through different lenses.

3.3 Road Three: Why the Tree Protects Information (Error Correction)

The standard approach to error correction is active: measure, detect, correct. The tree provides an alternative: passive protection, where the geometry itself prevents errors from accumulating.

Why? Because of the strong triangle inequality. On the tree, the worst-case error after many steps is bounded by the single worst step, not by the sum of all steps.

The Thermal Model (Arrhenius)

In a physical realization of the tree, each edge corresponds to a tunneling matrix element between adjacent states. The energy barriers grow with depth:

In thermal equilibrium at temperature $T$, the probability per unit time of a thermal fluctuation providing energy $\Delta_k$ is:

For realistic parameters—$\Delta_0 \approx 0.1$ meV, $T \approx 4$ K (achievable with relatively simple cryogenics), $p = 2$, $\alpha = 1$, and depth $D = 10$:

• $\Delta_{10} = 0.1 \times 2^{10} = 102.4$ meV
• $\Delta_{10} / k_B T = 102.4 / 0.345 \approx 297$
• $\exp(-297) \approx 10^{-129}$

The error rate is effectively zero—not one error in the age of the universe. This is exponential suppression with depth.

The Open-System Model (Lindblad)

A more complete treatment of decoherence uses the Lindblad master equation for the reduced density matrix $\rho$ of the tree system coupled to a bosonic bath:

where $H$ is the system Hamiltonian, $L_k$ are Lindblad jump operators specifying the decoherence channels, and $\gamma_k$ are the corresponding rates.

Three explicit jump operators for the tree system:

The ultrametric decoherence rate between vertices separated by tree distance $d(u,v)$ is:

The factor $p^{-\beta \cdot d(u,v)}$ reflects the ultrametric suppression: more distant vertices are weakly coupled and thus less susceptible to collective dephasing.

The Memory Model (Non-Markovian, HEOM)

The Lindblad equation assumes Markovian dynamics—the bath has no memory. For ultrametric systems with widely separated timescales, non-Markovian effects become important. The Hierarchical Equations of Motion (HEOM) describe the environment as a collection of modes at different frequencies, with the tree’s hierarchical structure directly reflected in the frequency distribution:

where $Q_k$ are system-bath coupling operators and $\nu_k$ are Matsubara frequencies.

Bath spectral density:

where $\omega_k = \Delta_k/\hbar$ are the characteristic frequencies at each depth. The hierarchical coupling $g_k = g_0 \cdot p^{-\gamma \cdot k}$ ensures that deeper states couple more weakly to the bath.

The memory model predicts the same exponential suppression as the simpler models, plus an additional signature: damped oscillations in the error rate at frequencies matching the tree’s hierarchical energy spacings. These oscillations are the “breathing” of the tree—the system partially forgets and then remembers its errors, at rates determined by the tree structure. Observing these oscillations experimentally would confirm the tree’s hierarchical structure in a way that no static measurement could.

Error Model Convergence

The convergence: All three models—thermal, Markovian, and non-Markovian—agree on the central result: errors decrease exponentially with tree depth, making fault-tolerant operation achievable at moderate depths. The non-Markovian models additionally predict observable oscillatory signatures that can serve as experimental confirmation of the hierarchical structure.

3.4 Road Four: The Mathematical Guarantee (Threshold Theorem)

A threshold theorem is a mathematical proof that error correction works at scale. It says: if your physical operations are reliable enough—if the probability of an error per operation is below some critical threshold—then you can make the overall computation arbitrarily reliable by adding more protection. The overhead—how many extra physical resources you need—grows manageably (polynomially, not exponentially) with the desired reliability.

For the surface code, the threshold theorem was proved in the late 1990s and early 2000s. The logical error rate scales as:

For the tree, a threshold theorem has been proved. It takes a slightly different form because the tree’s protection is geometric rather than measurement-based.

Theorem 3.5 (Ultrametric Threshold). For a logical qubit at depth $D$ in the Bruhat–Tits tree, with physical error probability $p_{\text{phys}}$ per elementary operation, the logical error probability satisfies:

Proof sketch. A logical error occurs if at least $D+1$ physical errors occur within a window of $2D+1$ gate operations. The binomial coefficient counts the number of ways to choose which $D+1$ operations fail. The term $p_{\text{phys}}^{D+1}$ is the probability of those failures; $(1-p_{\text{phys}})^D$ is the probability that the remaining $D$ operations succeed. This follows from the geometric fact—guaranteed by the strong triangle inequality—that fewer than $D+1$ errors within a window of $2D+1$ operations cannot change the logical state.

In plain terms: to get a logical error, more than half of the operations in a window of length $2D+1$ must fail simultaneously. The chance of this drops faster than exponentially with depth $D$.

Resource Comparison:

The tree uses fewer physical resources and pays zero energy cost for active error correction. The threshold theorem is proven. It is not a conjecture or a hope. It is a mathematical result that follows from the binomial distribution, the independence of errors, and the geometric fact—guaranteed by the strong triangle inequality—that fewer than $D+1$ errors cannot change the logical state.

3.5 Road Five: The Mathematics of Symmetry (The Langlands Program)

In 1967, the Canadian mathematician Robert Langlands wrote a 17-page letter to the French mathematician André Weil. The letter proposed a vast network of connections between two seemingly unrelated areas of mathematics: number theory (the study of whole numbers, primes, and equations) and harmonic analysis (the study of waves, symmetries, and representations).

This letter launched what is now called the Langlands program—one of the most ambitious and far-reaching research efforts in the history of mathematics. It has engaged thousands of mathematicians for over fifty years. It has produced Fields Medals, Abel Prizes, and a body of work that connects the deepest structures in number theory to the deepest structures in geometry and analysis.

For our purposes, the relevant branch of the Langlands program concerns the $p$-adic numbers. Specifically, it concerns the symmetry group of the $p$-adic tree.

A symmetry of an object is a transformation that leaves the object looking the same. The tree has a rich set of symmetries—distance-preserving transformations that permute branches, shift along geodesic rays, and combine these operations. The group of all such symmetries of the tree at prime $p$ is:

—the group of $2 \times 2$ invertible matrices with entries in the $p$-adic numbers.

The Langlands program, in its $p$-adic branch, classifies all the possible ways this symmetry group can act on different spaces. These possible actions are called representations. A representation takes an abstract group element—a symmetry of the tree—and turns it into a concrete unitary operation.

Here is why this matters for computing.

The operations you can perform on a quantum state living on the tree are precisely these representations. When you apply a gate—a controlled operation that moves the state from one point on the tree to another—you are implementing a representation of $\operatorname{GL}(2, \mathbb{Q}_p)$:

The catalog of all possible representations is the catalog of all possible gates. The Langlands program, pursued for purely number-theoretic reasons—to understand the distribution of primes, to solve Diophantine equations, to unify disparate areas of mathematics—accidentally provides the complete classification of computational operations on the tree.

Even more remarkably, the same structures appear in a completely different area of physics. In the 1990s, physicists studying a particular gauge theory ($\mathcal{N}=4$ super Yang-Mills theory in four dimensions) discovered a duality—the Kapustin–Witten S-duality—that independently reproduces the same classification of symmetries that the Langlands program produces.

Three independent fields converge:

1. Number theory—pursuing the distribution of primes

1. Gauge theory—pursuing the fundamental forces of nature

1. Tree-based computing—pursuing error-protected quantum computation

All three converge on the same symmetry group—$\operatorname{GL}(2, \mathbb{Q}_p)$—and the same classification of its possible actions.

Adelic computation. The adèle ring $\mathbb{A}_{\mathbb{Q}}$ is the “product” of all completions of $\mathbb{Q}$—the real numbers $\mathbb{R}$ and all $p$-adic fields $\mathbb{Q}_p$, subject to a compatibility condition. An adelic quantum computer uses a separate Bruhat–Tits tree $T_p$ for each prime $p$, with the adelic product formula acting as a global constraint. Computation proceeds within the constrained subspace where all trees are coherently linked. The adelic computer is speculative, but it follows naturally from the same mathematical structure.

The convergence: The Langlands program—a central research area in pure mathematics, pursued for entirely number-theoretic reasons—independently produces the same algebraic structures that govern quantum gates on the Bruhat–Tits tree. This is consilience: evidence from an unrelated field converging on the same mathematical object.

3.6 Road Six: Four Ways to Build It (Physical Platforms)

A theoretical proposal is strengthened when it can be realized in multiple physical systems. If only one material or technology can host the tree, the proposal might be an artifact of that particular platform. If several independent technologies can, the tree is likely a robust physical possibility.

Four different technologies—pursued by different research communities for entirely different reasons—can all be arranged to realize the tree geometry.

Platform 1: Superconducting Circuits

Superconducting qubits (transmons, fluxoniums) are the dominant technology in industrial quantum computing. To realize the tree, circuits are arranged not in a grid (as in the surface code) but in a tree pattern. Each circuit is a vertex. Tunable couplers between circuits are the edges.

• Gate speed: $\sim 10$ ns per gate
• Advantages: Mature fabrication (same factories that make conventional chips); tunable couplers; large existing knowledge base
• Challenges: Millikelvin temperatures require dilution refrigerators; 2D layout limits tree branching factor; existing infrastructure optimized for grid connectivity

Platform 2: Photonic Integrated Circuits

Photons—particles of light—naturally encode information in the path they take. A photon traveling through a network of optical fibers can be in a superposition of taking multiple paths simultaneously. By cascading beam splitters (partially reflective mirrors), you can create tree-structured networks of optical paths.

• Gate speed: $\sim 1$ ps per gate (fastest platform)
• Advantages: Room-temperature operation possible; natural path encoding; tree structure maps directly onto fiber layout
• Challenges: Photons rarely interact—entangling gates require nonlinear optical materials; photon loss; creating large numbers of identical single photons on demand

Platform 3: Trapped Ions

Each trapped ion is a natural qubit. Its internal energy levels serve as the computational basis states. Laser pulses tuned to the exact energy difference between levels can transfer the ion between states, creating superpositions. The connectivity is programmable in software—you define which ions are coupled by which laser pulses, and you can change the coupling pattern from one operation to the next.

• Gate speed: $\sim 100$ $\mu$s per gate
• Advantages: Longest demonstrated coherence times (seconds); software-defined topology; highest demonstrated gate fidelities
• Challenges: Ion-number scaling currently limited to dozens; gate operations relatively slow; significant engineering challenges in ion transport and laser addressing

Platform 4: Semiconductor Spin Qubits

An electron’s spin—a tiny bar magnet that can point up or down—serves as the qubit. In silicon or germanium crystals (the same materials used in every computer chip), individual electrons can be trapped in nanoscale structures called quantum dots. The coupling between neighboring spins is controlled by gate electrodes.

An alternative approach uses strain engineering—applying mechanical stress to create a landscape of varying potential energy. By designing the strain pattern to have a tree-like hierarchy, electrons arrange themselves in the tree geometry without needing individual gate electrodes for each coupling.

• Gate speed: $\sim 1$ ns per gate
• Advantages: CMOS-compatible fabrication (trillion-dollar semiconductor infrastructure); high integration density; potential for higher-temperature operation
• Challenges: Material imperfections create unpredictable local fields; valley physics adds complexity to energy level structure; single-electron control at scale

Platform-Independent Predictions

Regardless of the physical platform, the tree structure makes three specific, falsifiable predictions:

1. Logarithmic level spacing: $\log(\omega_k) = \log(\Delta_0/\hbar) + \alpha \cdot k \cdot \log(p)$—a straight line when plotting $\log$-frequency against depth. Curvature falsifies the tree model.

1. Hierarchical dephasing oscillations: Damped oscillations at frequencies matching the tree’s energy spacings. These oscillations are the unique signature of the hierarchical structure.

1. Exponential error suppression with depth: $P_{\text{error}} \lesssim \exp(-J(2D+1)/k_B T)$—the logarithm of the error rate falls linearly with depth.

These predictions are platform-independent. They can be tested in any of the four technologies. Success in any one platform confirms the theory. Failure in one platform might reflect implementation challenges specific to that platform. Failure in all four would falsify the theory—and that is how science should work.

4.1 The Convergence Table

Six independent lines of research, pursued by different communities for different reasons:

No one set out to build a quantum computer on a tree. Each community was investigating its own questions. The convergence emerged as a fact about the mathematics—discovered, not designed.

4.2 What Consilience Means

Consilience—from the Latin for “jumping together”—is a term introduced by the nineteenth-century philosopher William Whewell and revived by the biologist E. O. Wilson. It describes the principle that when evidence from independent, unrelated sources converges on the same conclusion, that convergence is itself a form of evidence—often stronger than any single source could provide.

Consider an example from geology. If a geologist studying rock formations, a paleontologist studying fossil distributions, and a chemist studying isotope ratios all independently conclude that a particular meteor impact occurred $66$ million years ago, their agreement is stronger than any one of their arguments alone. Each could be wrong for different reasons. Their joint convergence is highly unlikely unless the impact actually happened.

The same principle applies here. A philosopher of physics studying the measurement problem is led, by the need for a coherent account of collapse, to a geometry where projection is information loss rather than physical collapse. A number theorist studying prime numbers is led, by the $p$-adic absolute value, to the same geometric object. A quantum information theorist studying error correction is led, by the strong triangle inequality, to ultrametric spaces. An engineer building quantum hardware is led, by the need for robust connectivity, to tree-structured networks.

Each field arrives at the tree through its own independent reasoning. None was trying to support the others. The convergence is an emergent fact.

This does not prove that the tree is the correct state space for quantum computing. Proof requires experimental confirmation. But the convergence does establish that the tree is not an arbitrary choice, not a fad, not a mathematical curiosity. It is the natural geometric object at which multiple independent lines of inquiry intersect. It deserves to be taken seriously.

4.3 The Practical Claim

Current quantum computing rests on an unexamined assumption: that the state space—the set of possible configurations of the computer—should have ordinary (Archimedean) geometry. This geometry makes errors additive: small errors accumulate into large ones. This forces active error correction, which generates heat faster than it can be removed at scale. The result is a hard ceiling on the size of useful quantum computers.

There exists an alternative geometry—the tree—in which errors are not additive. The strong triangle inequality ensures that small deviations remain bounded. Error correction becomes a theorem of the geometry rather than an engineering overlay. No heat is generated by syndrome measurement because no measurement is needed.

The tree is not a human invention designed to solve the error correction problem. It was discovered in the study of prime numbers, in the late nineteenth century, decades before quantum mechanics existed. Its mathematical properties—the strong triangle inequality, the hierarchical branching, the connection to the mathematics of braiding and the classification of symmetries—were established for purely mathematical reasons, with no thought of computation.

Six independent lines of evidence now converge on this tree as the natural geometry for fault-tolerant quantum computation. The convergence is not proof, but it is strong circumstantial evidence. The theory is specific enough to be wrong—it makes concrete, quantitative predictions that can be tested. That is exactly what a scientific theory should do.

An honest proposal must acknowledge what is not yet known. Here are the open questions, stated plainly.

1. Can a small set of basic operations do everything? (The $p$-adic Solovay–Kitaev Problem)

For standard quantum computers, any computation can be built from a handful of basic gates. This is the Solovay–Kitaev theorem—proved independently in the 1990s—that guarantees a finite set of basic gates can approximate any operation to arbitrary precision with manageable overhead.

For the tree, the analogous question—whether a small set of tree operations can generate all possible tree operations—is open. Partial results exist: for operations at the tree’s root (depth 1), the answer is yes. For deeper operations, the question becomes whether tree isometries at different depths can be composed to approximate any target operation. The conjecture is that they can, with manageable overhead. The proof is not yet available.

2. Can the tree’s energy landscape be physically built?

The tree requires that the coupling strength between neighboring points drops in a specific pattern with depth: $J_k = J_0 \cdot p^{-\alpha k}$—exponential decay. Whether real materials can be engineered to exhibit this specific hierarchical coupling pattern is unanswered. Strain engineering in semiconductors, capacitive coupling in superconducting circuits, and programmable laser addressing in trapped ions all provide ways to tune coupling strengths. But achieving the precise exponential decay—across multiple orders of magnitude, with the correct exponent, while maintaining coherence—is an experimental challenge that has not yet been attempted.

3. Can different trees be coherently linked? (Adelic Quantum Computation)

There is a tree for each prime. The adelic product formula connects these trees into a single global structure. The idea of an “adelic computer”—where separate processors at different primes are linked by this product-formula constraint—is mathematically well-defined but physically speculative. Coherently coupling quantum systems at different primes would require a physical interaction that has no known experimental realization. The adelic computer is a long-term theoretical goal, not a near-term engineering target.

4. Does this actually outperform what we already have?

The threshold theorem provides a mathematical bound: for comparable error targets ($10^{-15}$ logical error rate), the tree uses fewer physical resources (~$200$ vertices vs. ~$900$ qubits) and zero error-correction energy. But a theorem is not an experiment. The theorem assumes uncorrelated errors and ideal gate operations. In a real device, errors are correlated, gates are imperfect, and the coupling pattern deviates from the ideal. Whether the practical advantage holds in real hardware is the question that only experiment can answer.

5. Can the architecture be extended to universal computation?

The current proposal handles operations that can be represented by braiding patterns—essentially, permutations and phase operations on the tree. This covers a restricted but useful class of computations. Extending to a fully universal gate set—one that can perform any quantum computation—while preserving the geometric error protection, is an active research area. The challenge: universal computation requires gates that create and manipulate entanglement in ways that go beyond braiding. Some proposals exist—using the adelic constraint to create entanglement between trees at different primes, or using hybrid architectures that combine tree protection with conventional gate operations—but none have been rigorously proven to preserve the tree’s error-protection properties.

6. Can the error models be experimentally validated?

The three error models make specific predictions:

• Thermal model: $\text{Rate} \propto \exp(-\Delta/T)$
• Open-system model: $\gamma(d) \propto d \cdot p^{-\beta \cdot d}$
• Memory model: Damped oscillations at tree frequencies $\omega_k = \Delta_0 \cdot p^{\alpha \cdot k} / \hbar$

These predictions have not been tested in a physical system. The models could be wrong—the thermal model might underestimate quantum tunneling, the open-system model’s jump operators might not capture all relevant noise sources, the memory model’s spectral density might not match the actual bath. Only experiment can distinguish between the models and validate or falsify them.

7. Non-abelian extensions?

The current architecture is limited to abelian topological sectors. Extending to non-abelian anyons would enable universal computation without the gate overhead of Solovay–Kitaev. This is an open theoretical question.

8. Fault-tolerant logical operations?

The transversal CNOT exists only for sibling qubits. A fully transversal universal gate set remains to be constructed. This bears directly on the scalability of fault-tolerant operations on the tree.

None of these open questions is fatal to the framework. They are the normal state of an active research program—the boundary between the known and the unknown. They define the work that needs to be done next.

We build quantum computers on a particular geometry—the geometry of everyday space, where distances add up and small errors accumulate—because we inherited this geometry from classical physics without questioning it. It forces active error correction. Active error correction generates heat. Heat cannot be removed fast enough at scale. There is a hard ceiling on how large these machines can become.

There exists an alternative geometry—the tree—where small errors are geometrically forbidden from accumulating. This geometry was not invented to solve the error correction problem. It was discovered in the study of prime numbers, over a century ago, for reasons that had nothing to do with computation.

Six independent lines of research—the foundations of quantum mechanics, the study of energy landscapes, the study of error correction, the theory of computational limits, pure mathematics, and physical engineering—all converge on this single geometric object.

The tree is not a metaphor. It is not a vague intuition. It is a precise mathematical structure with:

• A proven Hilbert space with an explicit computational basis and multi-qubit tensor product structure
• Five explicit Hamiltonians with spectral decompositions, energy gaps, and falsifiable predictions
• Three complete error models—thermal, open-system, and non-Markovian—all converging on exponential suppression with depth
• A proven threshold theorem with an explicit functional form and resource comparison against the surface code
• A catalog of gate operations classified by the Langlands program’s representation theory for $\operatorname{GL}(2, \mathbb{Q}_p)$
• Four candidate physical platforms—superconducting, photonic, trapped-ion, and spin qubit—all making the same three falsifiable predictions

The theory is specific enough to be wrong. That is its greatest strength. If the predicted logarithmic level spacing does not appear, if the hierarchical dephasing oscillations are absent, if the exponential error suppression fails—the theory is falsified. That is how science should work.

If the predictions are confirmed—if the tree can be built and it behaves as the mathematics says it should—we will have learned something fundamental: that the geometry of the state space matters, and that choosing the right geometry can turn error correction from an expensive, heat-generating engineering overlay into a free theorem of the shape.

Let the data decide.

All formal results cited in this document are published in the following releases (available at DOIs indicated and at qnfo.org\releases\).

The following matrix shows which publications address each of the six claims A checkmark (✓) indicates the publication addresses that claim. This is compiled from the systematic full-text search documented in 0.1.1.md.

Claim Coverage Summary:

Publication #1 (Ultrametric Quantum Computation and the Langlands Program) alone addresses all six claims simultaneously. Publications #2 and #8 each address five of six claims.

The following formal results are proven or established across the publication corpus.

This document is a synthesis of six prior drafts produced during the development of the ultrametric quantum computing framework. The source files, in order of creation, are:

Note on 0.1.md and 0.2.1.md: These documents were produced during a stress-testing phase designed to pressure-test the QWAV portfolio and identify weaknesses in the ultrametric computing framework. They served a valuable diagnostic function—the six claims in 0.1.md provided the specification against which subsequent publications were developed. Their content is excluded from this compilation, which focuses on the scientific synthesis proper.

This document is self-contained. No prior knowledge of quantum computing, number theory, or any specialized field is assumed. Every term is defined before use. If a sentence would not make sense to someone who has never taken a quantum mechanics course, that sentence was revised or removed.

The theory is falsifiable. It makes specific, quantitative predictions—logarithmic level spacing, hierarchical dephasing oscillations, exponential error suppression with depth—that can be tested in any of four physical platforms. Build the experiment. Measure the data. Let the evidence decide.