In conventional quantum computing, logic gates are continuous rotations on the Bloch sphere. A single‑qubit gate, such as the Hadamard gate, rotates the state vector by a specific angle. These rotations are analog: they require precise control of pulse amplitudes and durations. Any imperfection in the pulse—an over‑rotation, under‑rotation, or phase error—introduces a fidelity loss.
In a non‑Archimedean quantum computer based on the Bruhat‑Tits tree, logic gates are discrete isometries—transformations that map the tree onto itself while preserving distances. An isometry of the tree is a permutation of vertices that respects the adjacency structure. Because the tree is hierarchical, these isometries are naturally digital: they either happen or they don’t; there is no continuum of possible outcomes.
Consider a single qubit encoded as two disjoint balls on the tree, labeled $|0\rangle$ and $|1\rangle$. A logical NOT gate swaps the two balls. This swap is an isometry: it maps the entire subtree rooted at the $|0\rangle$ ball to the subtree rooted at the $|1\rangle$ ball, and vice versa. The swap is exact; there is no possibility of “partially swapping” because the tree has no continuous deformation that interpolates between the two configurations.
More general single‑qubit gates correspond to rotations of the tree around a vertex. For a vertex of degree $p+1$, the rotations form a finite group isomorphic to the dihedral group or a subgroup of the symmetric group $S_{p+1}$. For $p=2$, each vertex has three branches; the rotations permute these three branches. A rotation that cyclically permutes the three branches is analogous to a $2\pi/3$ rotation on the Bloch sphere, but here it is a discrete, exact operation.
Two‑qubit gates, such as the CNOT, are implemented by entangling isometries that correlate the branching choices of two qubits. For example, the CNOT gate can be realized as a conditional swap: if the control qubit is in $|1\rangle$, swap the target qubit’s two balls; else leave it alone. On the tree, this corresponds to a local rearrangement of subtrees that depends on the state of the control vertex.
Because these transformations are isometries, they are unitary in the quantum sense. The Hilbert space associated with the tree is the space of square‑summable functions on the vertices (or on the boundary). Isometries of the tree induce unitary operators on this Hilbert space. Thus, the gate set is provably quantum.
Over‑rotation errors are a major source of infidelity in conventional quantum gates. If a pulse intended to rotate by $\pi/2$ actually rotates by $\pi/2 + \delta$, the resulting state deviates from the desired one. These errors accumulate over a circuit, limiting the depth that can be achieved without error correction.
In a non‑Archimedean gate, there is no such thing as over‑rotation. The gate is a discrete permutation; either it executes correctly or it fails entirely. Failure modes are digital errors: the wrong permutation is applied, or the gate doesn’t fire at all. These errors are rare because they require crossing an energy barrier (as discussed in Chapter 17). Small control imperfections cannot cause a digital error; they merely fail to trigger the gate.
Consider the NOT gate implemented as a swap of two balls. To perform the swap, we apply a control pulse that lowers the energy barrier between the two ball configurations. If the pulse energy is above threshold, the system tunnels from one ball to the other, completing the swap. If the pulse energy is below threshold, nothing happens—the state remains unchanged. There is no intermediate outcome where the swap is partially executed. Thus, the gate is inherently digital.
This digital nature eliminates the need for calibration of rotation angles. In conventional systems, gates must be constantly calibrated to compensate for drift in control electronics or qubit frequencies. In a non‑Archimedean system, calibration reduces to ensuring that the control pulse exceeds the threshold—a much simpler task.
Moreover, gate fidelity is essentially 1.0 for pulses above threshold. The only infidelity comes from leakage—the possibility that the pulse excites the system into a non‑computational state (e.g., a higher‑energy ball not part of the qubit encoding). But leakage can be suppressed by designing the energy landscape to have a large gap between computational and non‑computational states.
Thus, non‑Archimedean gates achieve perfect analog accuracy by being digital. This is a paradigm shift: instead of fighting analog errors with better control, we design hardware that only supports digital operations.
A set of quantum gates is universal if any unitary operation can be approximated arbitrarily well by a sequence of gates from the set. For conventional qubits, a universal set consists of single‑qubit rotations and one two‑qubit entangling gate (e.g., CNOT). For qubits encoded on the Bruhat‑Tits tree, we need to identify a set of isometries that can approximate any unitary on the tree’s Hilbert space.
For a single qubit encoded on a $p+1$-regular tree, the local isometry group at a vertex is the symmetric group $S_{p+1}$ (all permutations of the $p+1$ branches). This group is finite, so it cannot generate continuous rotations. However, by using multiple vertices (i.e., a higher‑dimensional encoding), we can achieve a dense subset of unitaries.
A concrete proposal: encode a single logical qubit in a subtree of finite depth. The Hilbert space of that subtree is finite‑dimensional. The isometries that permute leaves of the subtree generate a finite group that is a subgroup of the unitary group $U(N)$. By composing such permutations, we can approximate any unitary in $U(N)$ to arbitrary precision, provided the group is universal in the sense of quantum computation. This is analogous to using discrete gate sets (e.g., Clifford+$T$) to approximate arbitrary unitaries.
For $p=2$, the simplest non‑trivial subtree is a binary tree of depth 2. This tree has 7 vertices (including root). Encoding a qubit in the 2 leaves at depth 2 gives a 2‑dimensional subspace. The isometries that swap these two leaves, combined with rotations that mix them with the other leaves, can generate any single‑qubit unitary.
For two‑qubit gates, we need entangling isometries that act on two subtrees simultaneously. An example is the controlled‑swap (Fredkin) gate: swap two leaves of the target subtree conditioned on the state of the control subtree. This gate, together with single‑subtree isometries, is universal for quantum computation.
Thus, a universal gate set for non‑Archimedean quantum computing consists of:
All gates are discrete, digital, and fault‑tolerant by construction.
While a physical implementation of a non‑Archimedean quantum computer remains speculative, we can simulate its behavior using classical or quantum simulators. The goal is to compare error rates with those of conventional architectures under realistic noise models.
We consider a simple model: a qubit encoded as two balls on a binary Bruhat‑Tits tree ($p=2$). The tree is truncated to depth $D$. Noise is modeled as random kicks that move the state along the tree with probability proportional to $e^{-\Delta E / k_B T}$, where $\Delta E$ is the energy barrier between adjacent vertices. Logical gates are implemented by instantaneously swapping subtrees (perfect digital operation).
Simulation parameters:
Results:
In contrast, a conventional superconducting qubit with similar physical parameters might have:
The non‑Archimedean qubit outperforms by orders of magnitude in error rate. This is not surprising: the simulation assumes perfect digital gates and an ultrametric noise model that suppresses small errors. The key question is whether such an ideal model can be realized in practice.
Challenges revealed by simulation:
Despite these challenges, the simulation demonstrates the potential of non‑Archimedean quantum computing: error rates can be extremely low without active error correction. This could enable shallow, high‑fidelity circuits that are currently impossible with noisy intermediate‑scale quantum (NISQ) devices.
Future work will need to address physical implementation. Candidate platforms include:
Even if a full‑scale non‑Archimedean quantum computer is decades away, the principles uncovered here—digital gates, passive fault tolerance, and ultrametric state spaces—could inspire new error‑mitigation techniques for existing architectures.
Chapter 18 has presented non‑Archimedean quantum logic gates as discrete isometries on the Bruhat‑Tits tree. These gates eliminate over‑rotation errors, are inherently digital, and can form a universal set for quantum computation. Simulations show dramatically lower error rates compared to conventional architectures, though practical realization remains a challenge.
With gates defined, we now step back to consider the broader ontological implications of the STC. The next chapter explores the idea of a timeless universe, where the tree is static and time emerges as an epistemic illusion.