🔢 mathematics

Intrinsic Redundancy and Local Robustness in Finite $\beta$ -Expansion Systems

This paper demonstrates that intrinsic redundancy in finite $\beta$ -expansion systems, particularly for multinacci bases, functions as a constrained-language resource for structural integrity through algebraic rewrite identities rather than a substitute for classical error-control redundancy, as genuine single-digit corruptions in canonical codebooks cannot be semantically recovered without external information.

Original authors: Adilbek Taizhanov, Miras Seilkhan

Published 2026-07-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Adilbek Taizhanov, Miras Seilkhan

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a secret language for counting numbers, but instead of using the usual "0" and "1" like a standard computer, you use a special rule: you are never allowed to write two "1"s next to each other.

If you try to write "11," the language breaks. It's like trying to park two cars in a single spot; the system screams, "Error! Forbidden pattern!" This is the world of $\beta$ -expansions, specifically using the "Golden Ratio" (a famous number roughly equal to 1.618) as the base for counting.

This paper is a detective story about what happens when you accidentally mess up a number written in this special language. Does the system fix itself? Does it know you made a mistake? And can it tell you what the number was before you broke it?

The Big Discovery: The "One-Flip" Dead End

The researchers ran thousands of simulations to see how robust this system is. They found a hard, unbreakable rule: If you change just one single digit (a "single-digit corruption"), the system can never magically guess what the original number was.

Think of it like this: You have a secret code "101." If a cosmic ray flips the middle "0" to a "1," you get "111." The system immediately knows "111" is illegal (because of the forbidden "11"). It can fix the syntax to make it legal again (turning it into "100"), but it has zero way of knowing if you started with "101" or if you started with something else that just happened to look like "100" after the flip.

The paper proves mathematically that without outside help (like a backup copy or a password), you cannot recover the original value from a single-digit mistake. The system can fix the shape of the number, but it cannot recover the story of what it used to be.

The "Magic" Exception: The Algebraic Kernel

However, there is a tiny, magical loophole. The paper found that if you mess up multiple digits at once in a very specific, patterned way, the number might stay exactly the same value, even though it looks different.

In the Golden Ratio system, there is a weird math trick: $100$ is exactly the same value as $011$.

$100$ means "one big unit."
$011$ means "one medium unit plus one small unit."
Because of the Golden Ratio's special math, these two different strings add up to the exact same number.

So, if a glitch changes a "100" into a "011," the system sees a forbidden pattern ("11"), fixes it back to "100," and the value never changed at all! The original meaning survived the crash.

But here's the catch: this only works if the glitch happens to match one of these rare, pre-existing math tricks. If the glitch is random (like a random burst of static noise), it almost never hits these magic patterns. The paper measured this: for random bursts of errors, the chance of the value surviving is tiny (less than 2% for the Golden Ratio system, and even smaller for more complex versions).

The Trade-Off: Strict Rules vs. Spacious Mess

The researchers compared this "No-Two-Ones" system (Golden Ratio) against:

Standard Binary: The normal computer way. It has no rules, so it never detects a mistake by looking at the shape. If you flip a bit, it just looks like a different valid number.
Signed NAF: A system that uses "-1, 0, 1" and has strict rules about not putting non-zero numbers next to each other.

They found a cool trade-off:

The Golden Ratio system is very strict. It catches about 43% of single-digit mistakes just by seeing the "forbidden" shape. Fixing it is cheap and fast (less than 1 repair step on average).
The Signed NAF system catches even more mistakes (about 49%) because its rules are tighter, but fixing them is expensive and slow (taking about 23 steps on average).
The Standard Binary system catches 0% of mistakes by looking at the shape. It's like a room with no furniture; you can throw a ball anywhere, and no one notices.

What the Paper Rules Out

The authors are very clear about what this system is NOT:

It is not a magic error-correcting code like the ones used to fix corrupted files on your hard drive or send messages to Mars. It cannot fix a single-digit error on its own.
It is not a way to store more information. In fact, because of the strict "no 11" rule, you can store fewer unique numbers in the same amount of space compared to standard binary. It's a "sparse" language.
It does not work perfectly at the edges. If a number gets too big or too small, the system has to chop off the ends (truncation) or lose the overflow, which introduces errors.

The Verdict

The paper concludes that this "intrinsic redundancy" is a structural safety net, not a time machine.

It can tell you: "Hey, this number looks weird! It has two 1s next to each other!" (Structural Detectability).
It can do: "Okay, I'll rearrange the digits to make it legal again." (Re-admissibilization).
It cannot do: "I know you meant to write 42, but you wrote 43. I'll change it back to 42." (Semantic Recovery).

Unless the mistake happens to be one of those rare, magical "value-preserving" patterns (like swapping $100$ for $011$), the original value is lost forever once a single digit is flipped. The system is great at spotting that a crash happened and cleaning up the mess, but it can't tell you what the mess looked like before the crash.

In short: It's a very good bouncer who checks IDs and kicks out the wrong people, but it's not a detective who can figure out who the person was before they got kicked out.

Technical Summary: Intrinsic Redundancy and Local Robustness in Finite $\beta$ -Expansion Systems

1. Problem Statement

Modern digital computation relies almost exclusively on binary representation, yet non-integer base systems ( $\beta$ -expansions) offer a broader design space where the base, digit alphabet, and admissible language can be chosen independently. While literature on analog $\beta$ -encoders and symbolic dynamics has established that non-integer bases (specifically $1 < \beta < 2$ ) exhibit semantic non-uniqueness (multiple distinct digit strings representing the same value), the operational value of this redundancy in finite digital arithmetic remains unclear.

The paper addresses a specific, narrow question: What operational robustness is supplied by intrinsic $\beta$ -redundancy when numbers are stored as finite canonical codewords? The authors distinguish between:

Ambient semantic non-uniqueness: The existence of multiple strings for a single value in the full space of digit strings.
Canonical codebook admissibility: The strict subset of strings selected for storage (e.g., the "no-adjacent-ones" rule in the golden-ratio base).

The core challenge is determining whether the intrinsic structure of these admissible languages can detect faults, repair corrupted states, or recover original values without external error-control mechanisms (like parity bits or Hamming codes).

2. Methodology

The study employs a bounded-window computational model to simulate finite-precision hardware. The methodology separates two distinct operational pipelines:

A. The Finite-Window Model

Window: A fixed integer width $W$ is defined with indices $I_{L,R} = \{-R, \dots, L\}$ .
Codebooks: Valid stored words must satisfy local admissibility constraints (e.g., no "11" for $\beta=\phi$ , no "111" for Tribonacci).
Boundary Effects: The model explicitly tracks overflow (writes beyond $L$ ) and truncation (writes below $-R$ ), acknowledging that exact value preservation may fail at boundaries.

B. Operational Pipelines

Arithmetic Canonicalization: Valid operands are added digit-wise, producing non-canonical intermediate states (e.g., digits $\ge 2$ or forbidden patterns). A deterministic MSB-first scheduler applies local rewrite rules (e.g., $011 \to 100$ for $\phi$ ) to restore admissibility.
Corruption Repair: An already stored admissible codeword is perturbed by a single-digit flip or a local burst corruption. The system attempts to repair the observed state via bounded-window normalization.

C. Evaluation Metrics

The paper defines a hierarchy of correctness criteria:

Structural Detectability: Does the corruption violate the admissibility constraints (making the word syntactically invalid)?
Structural Exactness (Value Preservation): Does the repair process return an admissible word with the same value as the corrupted word?
Semantic Survival: Does the repair process recover the original pre-fault value?
Cost: Measured by the number of rewrite operations ( $\kappa$ ) and propagation depth ( $\pi$ ).

D. Comparative Systems

The study compares:

Binary (B): Standard base 2, alphabet $\{0,1\}$ . Non-redundant baseline.
Signed NAF (S): Base 2, alphabet $\{-1, 0, 1\}$ with Non-Adjacent Form constraints. Represents alphabet-driven redundancy.
Golden-Ratio ( $\Phi$ ): Base $\phi$ , alphabet $\{0,1\}$ , forbidding "11".
Tribonacci ( $T_3$ ) & Tetranacci ( $T_4$ ): Higher-order multinacci bases with longer forbidden patterns ("111", "1111").

3. Key Contributions

A. Theoretical Results

Single-Digit Impossibility Result: The authors formalize that in any canonically injective finite codebook, genuine single-digit corruptions cannot be semantically recovered without external information. Since a single-digit change alters the numerical value, and the canonical codebook is injective (one-to-one mapping of value to string), value-preserving repair of the corrupted state yields a different value than the original state.
Algebraic-Kernel Condition for Semantic Survival: Semantic survival for multi-digit (burst) corruptions is possible if and only if the error vector lies in the algebraic kernel of the evaluation map. This occurs only when the corruption matches a value-preserving local identity (e.g., $100 \leftrightarrow 011$ in $\phi$ ).
Distinction of Redundancy Types: The paper rigorously separates ambient semantic multiplicity (a property of the infinite space) from canonical admissibility (the stored language). It argues that intrinsic redundancy is a constrained-language resource for structural integrity, distinct from classical error-control redundancy.

B. Experimental Findings

Structural Detectability:
- Binary has zero structural detectability (all bit flips are valid).
- Redundant systems (NAF, $\Phi$ , $T_3$ , $T_4$ ) detect a positive fraction of faults.
- Trade-off: Stricter languages (like $\Phi$ ) have higher detectability for single-digit faults than denser languages (like $T_4$ ), but at the cost of lower storage capacity (sparsity).
Repair Cost vs. Exactness:
- Signed NAF achieves the highest arithmetic exactness but requires high computational cost (global recoding).
- Local-rewrite systems ( $\Phi, T_3, T_4$ ) have very low repair costs (often $< 1$ operation on average for single-digit faults) but lower arithmetic exactness due to boundary truncation.
Semantic Survival:
- Single-digit: Zero survival rate for all systems (confirming the impossibility result).
- Burst corruption: Small, non-zero survival rates for redundant systems, strictly aligned with algebraic identities. For example, in $\Phi$ , a burst matching $100 \to 011$ survives; random bursts do not.
Boundary Effects: Lower-boundary truncation is a major source of error in non-integer bases. Adding guard digits effectively suppresses truncation but does not resolve upper-boundary overflow.

4. Results Summary

The experiments quantify the trade-offs across systems (at window width $W=24$ ):

Detectability: Signed NAF (0.489) > $\Phi$ (0.431) > $T_3$ (0.223) > $T_4$ (0.119).
Repair Cost: Signed NAF (23.03 ops) >> $\Phi$ (0.66 ops) > $T_3$ (0.26 ops) > $T_4$ (0.13 ops).
Semantic Survival (Burst): Signed NAF (2.3%) > $\Phi$ (1.8%) > $T_3$ (0.3%) > $T_4$ (0.1%).
Arithmetic Exactness: Signed NAF (75.3%) > Binary (49.2%) > $\Phi$ (32.3%) > $T_3$ (7.4%) > $T_4$ (1.7%).

The data indicates that $\Phi$ (Golden-Ratio) offers a favorable balance: it provides significant structural fault visibility and extremely low local repair costs, though it suffers from lower arithmetic exactness due to boundary truncation compared to Signed NAF.

5. Significance and Claims

The paper concludes with a modest but precise claim regarding the role of intrinsic $\beta$ -redundancy:

Not a General Error-Correcting Code: Intrinsic $\beta$ -redundancy does not function as a classical error-correcting code capable of recovering arbitrary single-digit corruptions. The "impossibility result" establishes a hard theoretical limit: without external information, the original value cannot be reconstructed from a single-digit fault.
A Constrained-Language Resource: Instead, intrinsic redundancy serves as a mechanism for structural fault visibility and value-preserving re-admissibilization. It allows a system to detect when a stored word has left the valid language and to repair it to a valid state that preserves the observed (corrupted) value.
Selective Semantic Survival: True recovery of the original value (semantic survival) is possible only for specific, algebraically aligned multi-digit perturbations (bursts) that match the system's local rewrite identities.
Architectural Implications: The study suggests that $\beta$ -expansions can provide a "native" mechanism for detecting structural violations and normalizing arithmetic intermediates with low local overhead, but they must be combined with other mechanisms (like guard digits or external checks) to handle boundary losses and generic error correction.

The authors emphasize that this work isolates the properties of the stored admissible language itself, separating it from the broader context of analog encoding or external error-control codes, providing a rigorous baseline for understanding the limits of intrinsic redundancy in finite digital systems.