Base X Addition Algorithm

• Base X addition algorithms are systematic methods for adding numbers in any positional system by treating numbers as digit arrays with propagated carries.
• They employ sequential, block-wise, and parallel strategies that leverage local rules, like carry-lookahead and window methods, to enhance computational efficiency.
• Innovations such as redundant digit sets and k-block paradigms enable operation in complex bases, achieving scalability and optimized performance.

A base X addition algorithm provides a systematic, digit-wise method for summing integers (or more general elements) in a positional numeration system with arbitrary radix β = X. The family of such algorithms encompasses the classical ripple-carry addition, block-wise integer addition as optimized for large operands, and parallel digit set conversion schemes tailored to algebraic (possibly complex) bases and specialized redundant digit sets. The unifying principle is the treatment of numbers as arrays of “digits” (or blocks/tokens) in base X with carries propagated, either sequentially or by constant-time local rules, to yield a representation of the sum in the same numeration system. The algorithmic details, complexity, and achievable parallelism depend critically on the base, the structure of allowable digit sets, and the local nature of the carry function.

1. Mathematical Formulation and Digit Arrays

Let β = X be the chosen base, which may be an integer, real algebraic number, or even a complex root. Any nonnegative integer A (possibly very large) can be written as:

$A = \sum_{i=0}^{n-1} a_i\,\beta^i$

with $a_i \in [0, \beta-1]$ for integer bases, or more generally $a_i \in \mathcal{A}$ for some fixed digit set $\mathcal{A}$ determined by the numeration system $(\beta, \mathcal{A})$ (Bassil et al., 2012, Legerský, 2017). For the sum $S = A + B$, the goal is to produce arrays $\{r_i\}$ of digits such that

$S = \sum_{i=0}^{n-1} r_i\,\beta^i$

with $r_i \in \mathcal{A}$. The structural properties of $\mathcal{A}$ and β—such as whether β is an algebraic integer with all conjugates outside the unit circle—govern the feasibility and design of efficient parallel algorithms (Legerský, 2017).

2. Sequential and Block-Wise Addition

The simplest form of base X addition follows the carry-propagation paradigm:

• For $i=0$ to $n-1$:
  • $s_i = a_i + b_i + c_{i-1}$
  • $r_i = s_i \bmod \beta$
  • $c_i = \lfloor s_i / \beta \rfloor$
  • with $c_{-1}=0$ and an extra digit appended if $c_{n-1}>0$ (Bassil et al., 2012, Dawes et al., 14 Jul 2025).

To maximize throughput for large operands, inputs are partitioned into blocks of $\lfloor \log_2 \beta \rfloor$ bits or $B$ decimal digits, so each fits in a machine word. The sequential block-wise addition models standard ripple-carry over tokenized arrays, achieving Θ(n) time where n is the number of blocks rather than bits (Bassil et al., 2012).

Table: Basic Block-wise Addition Workflow

Step	Formula	Output
Local sum	$s_i = a_i + b_i + c_{i-1}$
Reduction	$r_i = s_i \bmod \beta$	Digit $r_i$
Carry update	$c_i = \lfloor s_i / \beta \rfloor$	Next carry

This approach collapses bitwise complexity, leveraging register-width tokens and making non-power-of-two β feasible, subject only to word-size constraints (Bassil et al., 2012).

3. Parallel Addition and Digit Set Conversion

For optimal parallelism, algorithms decouple local digit additions from global carry resolution. The workflow is:

• Local sum phase: Parallel computation of $S_i = a_i + b_i$ in each block, ignoring carry chains.
• Carry determination: Compute local “generate” $g_i$ and “propagate” $p_i$ bits, then resolve inbound carries via a prefix-sum (or tree) scan of $(g,p)$ pairs. This is a classical carry-lookahead mechanism implemented in O(log n) time (Bassil et al., 2012).
• Final correction: With resolved carries $C_i$, output $r_i = (a_i + b_i + C_i) \bmod \beta$ in parallel.

This parallelization yields O(n/p + log n) time on p processors, with total work O(n). The minimal synchronization and block-level independence maximize utilization of modern multicore and vectorized hardware (Bassil et al., 2012).

For numeration systems with redundant digits or non-integer bases, parallel addition is formalized as a $p$-local digit set conversion: Given $$w_j = x_j + y_j \in \mathcal{B} = \mathcal{A} + \mathcal{A}$$, produce $$z_j = \varphi(w_{j+t}, ..., w_{j-r}) \in \mathcal{A}$$ (with fixed window size $p$). The function $\varphi$ can be implemented as a lookup table or explicit rule (Legerský, 2017, Frougny et al., 2011, Legerský et al., 2018).

4. Redundancy, Carry Structures, and Minimal Alphabet Size

Efficient parallel addition for arbitrary numeration systems and non-integer β requires careful selection of the digit set $\mathcal{A}$:

• Redundancy: $\mathcal{A}$ must be redundant so that $\mathcal{A} + \mathcal{A} \supsetneq \mathcal{A}$, providing local flexibility for carry absorption (Legerský et al., 2018).
• Minimal size: The digit set must cover all residue classes modulo $\beta$ and $\beta-1$. Lower bounds are $$\#\mathcal{A} \geq \max\{|m_\beta(0)|, |m_\beta(1)|\}$$, where $m_\beta(x)$ is the minimal polynomial of β (Legerský, 2017, Legerský et al., 2018).
• Symmetric/signed alphabets: For certain algebraic bases, optimal local rules exist for symmetric signed alphabets (e.g., $\{-1,0,1\}$ for the Golden Mean, or Avizienis-style for binary), permitting constant-time carry-free addition (Frougny et al., 2011).

Carry propagation rules can be cast in cohomological (group-theoretic) terms as cocycles $$f: \mathbb{Z}_b \times \mathbb{Z}_b \to \mathbb{Z}_b$$, where the standard rule is $f_1(n, m) = 1_{n+m \geq b}$ but general alternatives exist, especially for systems with high redundancy (Dawes et al., 14 Jul 2025).

5. Block and k-Block Parallel Addition in Non-Standard Numeration Systems

Kornerup’s k-block paradigm generalizes digit-wise addition to blocks (“super-digits”) of length k. In base β, blocks represent elements in base $\beta^k$, and the digit set is extended accordingly:

• $k$-block parallel addition leverages larger alphabets for smaller p-locality window, at the cost of more complex block-local mapping (Frougny et al., 2013).
• In d-bonacci bases, 1-block parallel addition requires an alphabet of size at least $d+1$; for sufficiently large k, $k$-block addition can operate on the minimal ternary alphabet $\{0,1,2\}$ (Frougny et al., 2013).
• For specific classes (e.g., Parry and Pisot numbers), explicit p-local k-block rules are constructed, realizing parallel addition on minimal alphabets (Frougny et al., 2013, Legerský et al., 2018).

6. Algorithms for Expanding Bases: Extending Window Method

The Extending Window Method (EWM) automates construction of local digit set conversion rules and constant-time addition algorithms for arbitrary expanding algebraic integer bases:

• Phase 1: Build a finite set of weight coefficients Q such that, for all $b \in \mathcal{B}$ and $q_{in} \in Q$, there is $q_{out} \in Q, a \in \mathcal{A}$ satisfying $b + q_{in} = a + \beta q_{out}$.
• Phase 2: Refine to a weight function

$q: \mathcal{B}^r \to Q$

by windowing over neighborhoods of size r, terminating when all contexts yield singleton carry choices.

• Final step: Addition proceeds by $z_j = w_j + q_{j-1} - \beta q_j$ in constant time and parallel depth (Legerský et al., 2018).

EWM subsumes classical rules (Avizienis, Chow–Robertson, Parhami) and provides explicit constructions for complex and non-integer β, as well as enabling k-block extensions for greater generality.

7. Structural Properties, Correctness, and Learnability

The algebraic correctness of base X addition algorithms is rooted in the properties of the carry function:

• Associativity and “infinite equivariance” hold exactly when the carry function is a group cocycle satisfying the cocycle condition, ensuring additivity and correct long-scale behavior (Dawes et al., 14 Jul 2025).
• Radical generalization—robust generalization to longer numbers in both neural and symbolic systems—is uniquely afforded by simple, single-value (e.g., standard “1”) carry functions. Multiple-valued cocycles yield correct algorithms only for bounded operand length (finite equivariance) and degrade in generalization ability (Dawes et al., 14 Jul 2025).
• Complexity metrics such as fractal border dimension of the carry table, carrying frequency, and associativity fraction quantify structural and computational trade-offs in different carry regimes, with classical carry rules being optimal for both humans and machines (Dawes et al., 14 Jul 2025).

8. Complexity, Implementation, and Optimization

• Time complexity: Sequential algorithms have Θ(n) time in the number of blocks/digits. Parallel digit set conversion or block-wise addition is O(1) depth (CREW-PRAM), with total work O(n) (Bassil et al., 2012, Legerský, 2017, Legerský et al., 2018).
• Space complexity: Lookup tables for p-local rules require storage O(|A+A|^p); block approaches balance alphabet size against table size (Frougny et al., 2013).
• Optimization: Maximal throughput is obtained by matching block size $k$ to register width, aligning memory for cache efficiency, minimizing synchronization, and exploiting vectorized instructions (SIMD, AVX2) when available (Bassil et al., 2012).
• Extension: On architectures supporting wide k, block-parallel methods further compress n, decreasing both time and storage overhead.

The interplay of algebraic properties of β, redundancy of $\mathcal{A}$, and the local nature of the carry function determines the efficiency, correctness, and generalizability of base X addition algorithms across classical, block, and parallel domains (Bassil et al., 2012, Legerský, 2017, Frougny et al., 2013, Legerský et al., 2018, Dawes et al., 14 Jul 2025).