Author: QNFO-QWAV Research
Date: 2026-06-03
Status: Draft — Architecture Review Complete
License: CC BY 4.0
Source: Derived from Section 10 of "Quantum Cryptanalysis 2026" (v3.0, DOI: 10.5281/zenodo.20517893)
---
This document specifies a public benchmark for ultrametric quantum computation (UQC), modeled on the ecdsa.fail challenge format. The benchmark tests the ability to perform p-adic modular exponentiation — the ultrametric analog of the elliptic curve point addition targeted by ecdsa.fail — using only branch-respecting quantum operations. Submissions are scored by total branch operations × tree depth, with cross-branch penalties proportional to tree distance. A reference verifier is specified.
Certainty: This benchmark is [speculative] — no working ultrametric quantum computer exists, and the computational model is theoretical. The benchmark serves as a target specification to guide hardware and algorithm development, analogous to how ecdsa.fail guided Shor-circuit optimization even before fault-tolerant hardware exists.
This benchmark would be disconfirmed if p-adic computation proves no more efficient than binary computation for the specified target problem, or if hierarchical error confinement fails at the scales required for 256-bit arithmetic.
---
Given p-adic representations of three integers $a$, $b$, $p$ (where $p$ is a 256-bit prime, e.g., the secp256k1 modulus), compute:
$$c = a^b \bmod p$$
Subject to the following constraints:
- All quantum operations must respect the p-adic hierarchical (tree) structure. An operation at branch depth $d$ may affect only qubits in the subtree rooted at $d$.
- Cross-branch operations (operations spanning distinct subtrees) are permitted but incur a scoring penalty proportional to the tree distance between branches.
- The final output $c$ must be recoverable via the Monna map applied to the quantum state at readout.
An integer $x \in [0, p-1]$ is encoded as its base-$p_i$ digit expansion (or equivalently, base-2 digit expansion with hierarchical digit grouping). Each digit occupies one branch of the hierarchical tree. The tree depth $D$ equals the number of digits in the expansion.
For the 256-bit target: $D = \lceil 256 / w \rceil$ where $w$ is the digit width (e.g., $w = 4$ bits per digit gives $D = 64$ tree levels).
An operation is branch-respecting if, for every qubit it touches, all other qubits it touches belong to the same branch subtree. Specifically:
- A gate at depth $d$ of the tree acts within a single subtree whose root is at depth $d$.
- Gates at the root level ($d = 0$) may act across all subtrees — these correspond to operations on the most significant digit that genuinely couples all branches.
The tree distance between two branches is the depth of their lowest common ancestor. Two leaves at depth $D$ sharing an ancestor at depth $d$ have tree distance $D - d$.
---
$$\text{Score} = \text{BranchOps} \times \text{TreeDepth}$$
Where:
- $\text{BranchOps} = \sum_i (\text{cost of gate } i \times \text{tree}_{\\text{distance penalty for gate } i})$
- $\text{TreeDepth} = \text{number of digit levels (qubit count analog)}$
Lower score is better.
| Gate | Cost | Tree Distance Penalty |
| -- | ||
|---|---|---|
| Single-qubit (within branch) | 1 | $\times 1$ |
| Two-qubit (same branch) | 2 | $\times 1$ |
| Two-qubit (cross-branch, distance $k$) | 2 | $\times (1 + \alpha k)$ |
| Multi-qubit (across $n$ branches) | $n^2$ | $\times \max_{\\text{pairs}}(\text{distance penalty})$ |
Where $\alpha$ is a penalty parameter (default: $\alpha = 0.5$). Cross-branch operations are permitted but penalized to incentivize hierarchical designs.
At least 99.9% of test shots (e.g., 9,000 of 9,024) must produce the correct classical output after Monna map readout. Padding residue (approximate correctness) is permitted if the residue magnitude is bounded.
| Dimension | ecdsa.fail | UQC Benchmark |
| -- | ||
|---|---|---|
| Target | secp256k1 point add | p-adic $a^b \bmod p$ (256-bit) |
| Gate cost metric | Toffoli count | BranchOps (branch-respecting gate count) |
| Qubit metric | Peak qubits | Tree depth |
| Score | Toffoli × qubits | BranchOps × depth |
| Correctness | Approximate (Shor-tolerant) | Monna-mapped approximate |
| Cross-operation penalty | None (flat qubit grid) | $\alpha \times$ tree distance |
---
The verifier is a ZK-proof harness (inspired by Google's quantum_ecc harness used by ecdsa.fail) that:
1. Accepts a circuit submission in a specified intermediate representation (IR).
2. Simulates the circuit with a classical simulator that tracks:
- Branch membership of every qubit
- Gate count, classified by branch-respecting status
- Tree depth allocation
3. Applies the Monna map to the simulated output and compares against the expected classical result.
4. Computes the score using §3.
5. Returns a pass/fail verdict with detailed metrics.
The reference verifier shall be implemented in Python with:
- A tree data structure representing the hierarchical qubit layout
- A gate IR supporting single-qubit, two-qubit (same-branch and cross-branch), and multi-controlled gates
- A classical simulator (state vector for small depths; tensor network for larger)
- Monna map implementation for base-$p$ digit reversal
- Test vectors: known $(a, b, p, c)$ tuples for validation
The verifier shall validate submissions against pre-computed truth tables:
| Parameter | Example Values |
| -- | - |
|---|---|
| $p$ | secp256k1 prime: $2^{256} - 2^{32} - 977$ |
| $a$ | Random 256-bit integers |
| $b$ | Random 256-bit integers |
| $c_{\\text{expected}}$ | $a^b \bmod p$ (classically computed) |
---
| Option | Description | Trade-off |
| -- | - | -- |
|---|---|---|
| A: ecdsa.fail fork | Add UQC module to existing gpsanant/ecdsafail-challenge | Leverages existing infrastructure, Rust toolchain |
| B: QWAV Pages endpoint | New Cloudflare Pages site at uqc.qnfo.org or similar | Full QNFO branding, independent lifecycle |
| C: Hybrid | Python verifier on Pages, submissions via ecdsa.fail-format CLI | Fastest to launch, lower effort |
Recommendation: Option C (hybrid) for v0.1 — deploy verifier to Cloudflare Pages, define submission CLI spec compatible with ecdsa.fail format.
`json
{
"benchmark": "uqc-v0.1",
"target": "p-adic modexp",
"params": {"p": "secp256k1", "a_bits": 256, "b_bits": 256},
"circuit": {
"tree_depth": 64,
"branch_ops": 1234567,
"cross_branch_ops": 42,
"gates": [...]
},
"score": {"branch_ops_weighted": 1234567, "tree_depth": 64, "total": 79012345},
"build_note": "Description of optimization strategy"
}
`
---
1. [speculative] No working ultrametric quantum hardware exists. This benchmark targets a theoretical computation model.
2. [unverified] The Monna map readout has not been experimentally validated for quantum computation.
3. [approximate] The scoring penalty parameter $\alpha$ is heuristic; optimal value to be determined through challenge iteration.
4. [simplified] The reference verifier uses classical simulation; a ZK-proof verifier (like Google's quantum_ecc) requires significant development effort.
5. [blocked on research] Hierarchical error confinement claims need experimental validation before the benchmark's error model (branch-respecting only) can be considered physically justified.
---
| Phase | Task | Status |
| - | -- | |
|---|---|---|
| 1 | Architecture review complete | ✅ Done |
| 2 | Draft benchmark specification | ✅ This document |
| 3 | Implement reference verifier (Python) | ❌ Next |
| 4 | Create test vectors | ❌ After Phase 3 |
| 5 | Deploy to Cloudflare Pages | ❌ After Phase 4 |
| 6 | Public launch + Zenodo DOI | ❌ After Phase 5 |
| 7 | Iterate based on submissions | ❌ Post-launch |
---
1. QNFO-QWAV. "Quantum Cryptanalysis 2026: From Shor's Dead End to Ultrametric Quantum Computing." v3.0, 2026. DOI: 10.5281/zenodo.20517893.
2. QNFO-QWAV. "Ultrametric Quantum Computation." May 2026. Archive: G:\My Drive\Archive\projects\2026\05\Ultrametric Quantum Computation\.
3. QNFO-QWAV. "Validation of Ultrametric Error Confinement." May 2026. Archive.
4. QNFO-QWAV. "Ultrametric Relaxation Dynamics in Topological Quantum Memory." February 2026. Archive.
5. ecdsa.fail Challenge. gpsanant/ecdsafail-challenge. 2026.
6. Google Quantum AI. "Quantum Cryptanalysis of ECDSA with Fewer Qubits." 2026. [speculative — undisclosed verifier].
---
This specification is a living document. Version 0.1. Next revision after reference verifier implementation.