Constant-Time Certificate Selector

• Constant-Time Certificate Selector is a geometry-driven decision procedure that uses only faulty coordinate data to determine repair certificates in dense Gaussian and Eisenstein–Jacobi networks.
• It employs a fixed set of algebraic and combinatorial tests to classify fault geometry for one- and two-fault scenarios, ensuring minimal external repair edges in O(1) time and memory.
• The method guarantees bounded-depth reconnection in broadcast trees, with depth limits of k+2 for Gaussian networks and t+1 or t+2 for Eisenstein–Jacobi networks depending on fault count.

Searching arXiv for the cited papers and closely related terminology. A constant-time certificate selector is a geometry-driven decision procedure for local broadcast repair in dense Gaussian networks $G_k$ and dense Eisenstein–Jacobi networks $H_t$. In the setting of one-to-all broadcast, the underlying fault-free structure is a source-centered coordinate-reduction tree, but processor faults can delete vertices from that tree and split it into multiple healthy components. For the one- and two-fault regime $|F|\le 2$, the selector uses only the faulty coordinates to classify the relative fault geometry, choose a coordinate-reduction orientation, and return a bounded ordered set of component-crossing repair edges. Its defining property is that certificate selection itself runs in $O(1)$ time and $O(1)$ memory, while preserving non-redundancy and depth guarantees for the repaired broadcast tree (Albader, 19 Jun 2026).

1. Concept and problem setting

The selector arises in the repair of a non-redundant one-to-all broadcast tree. In the fault-free network, every vertex has a unique parent chosen so that the graph-layer metric strictly decreases toward the source. Each healthy processor therefore receives the message exactly once. When processor faults occur, vertices are deleted from the tree, producing a forest

$T-F = C_1\cup C_2\cup \cdots \cup C_c,$

where the $C_i$ are the healthy components. The repair objective is not to reconstruct the tree globally, but to preserve the healthy components and reconnect them with the minimum number of new external component-crossing edges (Albader, 19 Jun 2026).

If the fault-pruned tree has $c$ components, then any repaired tree that preserves those components needs at least $c-1$ external component-crossing repair edges. This is the standard connectivity lower bound obtained by contracting each component to a supernode. The constant-time certificate selector is designed to meet that lower bound for the selected orientation while also maintaining a bounded depth (Albader, 19 Jun 2026).

The paper’s stronger formulation is that, for $|F|\le 2$, selecting the repair plan does not require a linear scan of the network. The selector receives the network family, the parameter $H_t$0 or $H_t$1, and the fault set $H_t$2, and from those coordinates alone returns a repair certificate in constant time (Albader, 19 Jun 2026).

2. Algebraic network models

The selector is defined for two algebraic interconnection-network families with compact coordinate balls, fixed degree, and simple modular addressing (Albader, 19 Jun 2026).

Network	Canonical region	Layer metric
Dense Gaussian $H_t$3	$H_t$4	$H_t$5
Dense EJ $H_t$6	$H_t$7	$H_t$8

For dense Gaussian networks, the generator is

$H_t$9

with order

$|F|\le 2$0

and coordinate-to-label map

$|F|\le 2$1

The resulting broadcast layers are diamond-shaped and centered at the source $|F|\le 2$2 (Albader, 19 Jun 2026).

For dense Eisenstein–Jacobi networks, the generator is

$|F|\le 2$3

with order

$|F|\le 2$4

and coordinate-to-label map

$|F|\le 2$5

The six unit directions are

$|F|\le 2$6

so the layer structure is hexagonal, with six natural ray directions (Albader, 19 Jun 2026).

These algebraic representations are not incidental. They permit the selector to test adjacency and wraparound using modular label differences rather than global geometric search, which is one of the foundations of the $|F|\le 2$7 formulation (Albader, 19 Jun 2026).

3. Coordinate-reduction trees and depth certificates

A coordinate-reduction orientation is a deterministic parent rule $|F|\le 2$8 such that for every non-source vertex,

$|F|\le 2$9

Each parent step moves one layer closer to the source, so cycles are impossible and all vertices reach the source in at most the diameter. In $O(1)$0, a coordinate-reduction tree has depth at most $O(1)$1; in $O(1)$2, it has depth at most $O(1)$3 (Albader, 19 Jun 2026).

The paper introduces a depth certificate as the formal object returned by the selector. Given components $O(1)$4, a $O(1)$5-depth certificate is an ordering of the non-source components together with crossing edges $O(1)$6 such that $O(1)$7 lies in the next component to be attached, $O(1)$8 lies in the already repaired part, and

$O(1)$9

Here $O(1)$0 is the depth of the repaired-side endpoint, and $O(1)$1 is the eccentricity of $O(1)$2 within its component (Albader, 19 Jun 2026).

The central lemma states that if $O(1)$3 admits a $O(1)$4-depth certificate using $O(1)$5 external edges, then adding those edges yields a non-redundant repaired broadcast tree of depth at most $O(1)$6, and the number of external repair edges is minimum for that selected orientation. In this framework, “certificate selection” means selecting exactly such a bounded ordered list of repair edges, together with the orientation under which the certificate is valid (Albader, 19 Jun 2026).

The depth proofs rely on suffix inequalities. For Gaussian suffixes, if a detached suffix $O(1)$7 has entry $O(1)$8 beyond cut layer $O(1)$9, then under the stated bounds on $T-F = C_1\cup C_2\cup \cdots \cup C_c,$0 and repaired-side depth,

$T-F = C_1\cup C_2\cup \cdots \cup C_c,$1

or, in the stronger case,

$T-F = C_1\cup C_2\cup \cdots \cup C_c,$2

For EJ suffixes cut at layer $T-F = C_1\cup C_2\cup \cdots \cup C_c,$3, the analogous bounds imply attachment value at most $T-F = C_1\cup C_2\cup \cdots \cup C_c,$4 or at most $T-F = C_1\cup C_2\cup \cdots \cup C_c,$5, depending on the repaired-side depth assumption (Albader, 19 Jun 2026).

4. Selector mechanics and constant-time operation

The selector is an algorithm with five tasks: it receives the network family and parameter, reads the fault set $T-F = C_1\cup C_2\cup \cdots \cup C_c,$6 with $T-F = C_1\cup C_2\cup \cdots \cup C_c,$7, classifies the relative fault geometry, chooses one coordinate-reduction orientation, and returns a bounded ordered list of repair edges. It does not scan all vertices or compute components by global search (Albader, 19 Jun 2026).

Its constant-time behavior is achieved by restricting the computation to a fixed number of local algebraic and combinatorial tests. The paper explicitly states that the selector uses only a fixed number of integer comparisons, sign tests, sector or ray index computations, and modular adjacency tests. Consequently, certificate selection runs in

$T-F = C_1\cup C_2\cup \cdots \cup C_c,$8

time and

$T-F = C_1\cup C_2\cup \cdots \cup C_c,$9

extra memory (Albader, 19 Jun 2026).

This bound applies to repair-plan selection rather than to full materialization of the repaired tree. If all parent assignments must be written explicitly, then outputting the full repaired parent map still requires

$C_i$0

time and memory. The distinction between selector cost and output cost is one of the paper’s central technical points (Albader, 19 Jun 2026).

The algebraic primitives supporting these decisions are the quotient-neighbor maps. For Gaussian networks,

$C_i$1

and for EJ networks,

$C_i$2

These maps encode boundary wraparound algebraically: a candidate repair edge is valid when its label difference matches a generator modulo the network order (Albader, 19 Jun 2026).

5. Fault-geometry classification and certificate construction

The selector is organized as a constant-size case table indexed by normalized fault geometry. In the Gaussian setting, a coordinate is axis if $C_i$3 and off-axis otherwise. For two axis faults, the table distinguishes same ray, opposite rays, and orthogonal axes; other cases include one axis plus one off-axis, two off-axis faults, and a special diagonal-adjacent mixed case. Reflection and, in some cases, coordinate exchange $C_i$4 reduce the analysis to canonical representatives (Albader, 19 Jun 2026).

The Gaussian selector chooses among several coordinate-reduction orientations, including $C_i$5-first, axis-priority, the O3 side-entry tree, and the O6 reflected orthogonal-axis tree. The most important hard case is the orthogonal-axis O6 case. For normalized faults

$C_i$6

the selector may split the tree into up to five fault-pruned components and uses at most four repair edges: $C_i$7

$C_i$8

$C_i$9

$c$0

Some components may be empty, and empty components are omitted; the certificate count is then exactly $c$1 for the selected orientation (Albader, 19 Jun 2026).

In the EJ setting, the classification distinguishes ray-resident faults, sector-interior faults, ray/ray pairs, ray/sector mixed pairs, and sector/sector pairs, with further subdivisions into same ray, opposite rays, other ray pairs, adjacent-sector or same-sector pairs, and non-adjacent sector pairs. A dihedral symmetry normalization again reduces the table to constant size (Albader, 19 Jun 2026).

The EJ selector uses compact operators. For a ray vertex $c$2,

$c$3

If $c$4, then

$c$5

and if $c$6, the tail is empty. For a sector-interior fault $c$7 with $c$8,

$c$9

$c-1$0

$c-1$1

The ordered sector list $c-1$2 is chosen according to the location of the other fault so that blocked boundaries can be avoided (Albader, 19 Jun 2026).

These case distinctions show that the selector is not a generic search procedure. It is a finite geometry-dependent rule set that maps normalized fault coordinates directly to an orientation and a short repair certificate (Albader, 19 Jun 2026).

6. Theoretical guarantees and exhaustive validation

The Gaussian theorem states that for every $c-1$3 and every source-free fault set $c-1$4 with $c-1$5, the selector returns a coordinate-reduction orientation, returns exactly $c-1$6 external component-crossing repair edges, produces a non-redundant repaired tree, and guarantees depth at most

$c-1$7

For dense EJ networks, the corresponding theorem states that for every $c-1$8 and every source-free fault set $c-1$9 with $|F|\le 2$0, the selector returns a coordinate-reduction orientation, returns exactly $|F|\le 2$1 external component-crossing repair edges, and guarantees depth at most

$|F|\le 2$2

for one fault and

$|F|\le 2$3

for two faults (Albader, 19 Jun 2026).

The phrase “returns exactly $|F|\le 2$4 external component-crossing edges” has a precise meaning. Each repair edge joins two different healthy components, and a connected graph on $|F|\le 2$5 contracted components needs at least $|F|\le 2$6 such edges. The selector therefore produces an edge-minimal repair plan for the chosen orientation, with no redundant inter-component edges (Albader, 19 Jun 2026).

The paper reports exhaustive strict validation. For Gaussian networks, the validation covers

$|F|\le 2$7

with

$|F|\le 2$8

one- and two-fault cases and zero failures in connectivity, acyclicity, exact $|F|\le 2$9 repair count, or depth bound. The maximum depth always matched the bound $H_t$00, and the largest component count observed was 5 in the O6 family. For EJ networks, the validation covers

$H_t$01

with

$H_t$02

cases and zero failures in connectivity, acyclicity, exact $H_t$03 repair count, or depth bound; the run confirms one-fault depth $H_t$04 and two-fault depth $H_t$05 (Albader, 19 Jun 2026).

These results establish the selector as a formally analyzed repair-plan computation for the one- and two-fault regime, rather than only a heuristic case analysis (Albader, 19 Jun 2026).

7. Significance, scope, and terminological distinction

The selector is significant because it replaces search-based repair-plan selection with a constant-size certificate computation. Earlier search-based repair methods typically inspect the network or tree globally, scan for crossing edges, compute components explicitly, and then choose a repair plan; that is at least linear in network size. By contrast, the constant-time selector looks only at the fault coordinates, classifies the geometry, and returns the repair plan directly using algebraic adjacency and quotient-neighbor tests (Albader, 19 Jun 2026).

Its scope is also sharply delimited. The constant-time guarantee is proved for the one- and two-fault regime $H_t$06, and the selector returns a repair certificate for a selected fault-pruned orientation. A plausible implication is that the method is best understood as an exact finite-case synthesis for low-cardinality fault patterns rather than as a general-purpose global repair algorithm.

The term “certificate selector” has a distinct meaning here from its use in interactive proof-based classification. In the latter setting, a prover selects a certificate from a datapoint and sends it to a verifier who decides the class; certificate selection is analyzed in terms of completeness, soundness, precision, and Asymmetric Feature Correlation (Wäldchen, 2023). In local broadcast repair, by contrast, the certificate is a depth certificate consisting of an ordered list of component-crossing repair edges together with an orientation sufficient to prove bounded-depth reconnection (Albader, 19 Jun 2026). This distinction prevents a common terminological confusion: in network repair, the certificate is a constructive reconnection witness, not an explanatory feature used for classification.