Fibonacci-Automatic Sequences

• Fibonacci-Automatic Sequences are defined by DFAs that process Zeckendorf representations, enabling precise arithmetic relations and subsequence operations.
• Automata constructions yield low state complexity for equality, ordering, and addition, converting exponential bounds into polynomial ones.
• The framework supports efficient sequence shifts and linear subsequence extraction, significantly reducing morphic complexity in practical applications.

Searching arXiv for the cited papers and closely related work. arXiv search: "Complexity of Linear Subsequences of Fibonacci-Automatic Sequences" Fibonacci-automatic sequences are sequences $(h(i))_{i\ge 0}$ generated by a DFAO that reads the Fibonacci, or Zeckendorf, representation of the index $i$. In this setting, arithmetic relations on indices and structural operations on sequences are studied through finite automata over canonical Fibonacci representations, with particular emphasis on state complexity and constructive complexity. The central results on linear subsequences establish automata for equality, order, addition by a constant, and general linear forms $[y]=n[x]+c$, and then transfer these constructions to shifted sequences and subsequences of the form $h(n\,i+c)$. As a consequence, the morphic complexity of such subsequences admits a polynomial bound, improving a recent exponential bound for the Fibonacci word (Moradi et al., 23 Mar 2026). Related work uses the same Zeckendorf-automatic framework to analyze Wythoff sumsets via Walnut (Shallit, 2020) and to study synchronized Fibonacci sequences such as A105774 (Cloitre et al., 2023).

1. Numeration-theoretic foundations

Let $\{F_n\}_{n\ge 0}$ be the Fibonacci numbers defined by

$$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$

A Fibonacci, or Zeckendorf, representation of a nonnegative integer $m$ is a binary word

$m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$

subject to the non-consecutivity condition $e_i e_{i+1}=0$. The corresponding bit vector is written most-significant-digit first as $(e_t e_{t-1}\dots e_2)$, and $i$0 denotes the integer value of a binary string $i$1 (Moradi et al., 23 Mar 2026).

Zeckendorf’s theorem gives both existence and uniqueness: every $i$2 has such a representation, and there is exactly one such representation with no leading zeros. This uniqueness is the numeration-theoretic basis for deterministic automata over Fibonacci representations. In the terminology used for Fibonacci-automatic sequences, if a DFAO $i$3 with $i$4 states reads the Zeckendorf representation of $i$5 and outputs $i$6, then $i$7 is Fibonacci-automatic and its state-complexity is $i$8 (Moradi et al., 23 Mar 2026).

A related but stronger model is the synchronized automaton for a function $i$9: a DFA over alphabet $[y]=n[x]+c$0 that reads in parallel a pair of Fibonacci representations and accepts exactly those pairs $[y]=n[x]+c$1 such that $[y]=n[x]+c$2. Synchronized automata are described as strictly more powerful, because they permit first-order reasoning about $[y]=n[x]+c$3 in the structure $[y]=n[x]+c$4 (Cloitre et al., 2023). This distinction matters for complexity questions: DFAO-based automaticity controls sequence generation, while synchronized automata control graph recognition and logical definability.

2. Automata for basic arithmetic relations

The core arithmetic constructions use msd-first DFAs, more precisely partial DFAs to handle dead-state omission, over the alphabet $[y]=n[x]+c$5. These automata read a pair $[y]=n[x]+c$6 in parallel, where $[y]=n[x]+c$7 and $[y]=n[x]+c$8 are Zeckendorf-encoded, and recognize relations such as equality, ordering, addition by a constant, and general linear forms (Moradi et al., 23 Mar 2026).

Relation	Recognized set	State-complexity
Equality	$[y]=n[x]+c$9	$h(n\,i+c)$0
Ordering	$h(n\,i+c)$1	$h(n\,i+c)$2
Addition by constant	$h(n\,i+c)$3	$h(n\,i+c)$4
Linear form	$h(n\,i+c)$5	$h(n\,i+c)$6

Equality is recognized by a 2-state DFA, plus a dead state in the classic construction. Ordering is recognized by a 5-state DFA because lexicographic order on valid Zeckendorf strings agrees with numeric order: $h(n\,i+c)$7 This equivalence is one of the key structural simplifications of the Fibonacci numeration system (Moradi et al., 23 Mar 2026).

For addition by a constant $h(n\,i+c)$8, the automaton tracks the running difference

$h(n\,i+c)$9

together with the previous difference $\{F_n\}_{n\ge 0}$0 and the last input bits $\{F_n\}_{n\ge 0}$1. States are 4-tuples $\{F_n\}_{n\ge 0}$2 with $\{F_n\}_{n\ge 0}$3. The decisive argument is a range-stability property: once $\{F_n\}_{n\ge 0}$4 leaves $\{F_n\}_{n\ge 0}$5, no extension can return, and the set of co-accessible states is bounded by $\{F_n\}_{n\ge 0}$6 (Moradi et al., 23 Mar 2026).

For the general linear relation $\{F_n\}_{n\ge 0}$7, the construction maintains

$\{F_n\}_{n\ge 0}$8

as the current and previous differences together with the last input bits of $\{F_n\}_{n\ge 0}$9 and $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$0. The analysis shows that $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$1 remains in the integer interval

$$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$2

whose size is $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$3. With two bits for the last symbols of $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$4 and $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$5, this yields

$$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$6

states (Moradi et al., 23 Mar 2026).

Two lemmas organize much of this arithmetic. First, for every valid Fibonacci string $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$7,

$$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$8

Second, if $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2}\quad(n\ge 2).$$9, then extending by one more digit $m$0 gives the difference recurrence

$m$1

This recurrence supplies the single-step transition rule for the linear-form automata (Moradi et al., 23 Mar 2026).

3. Sequence operations and linear subsequences

The same automata-theoretic apparatus extends from binary relations on encoded integers to operations on Fibonacci-automatic sequences themselves. Three operations receive explicit complexity bounds: shifting by a constant, shifting the Fibonacci-Thue–Morse sequence, and extracting linear subsequences (Moradi et al., 23 Mar 2026).

If $m$2 is generated by an $m$3-state DFAO, then for fixed $m$4 the shifted sequence $m$5 is generated by a DFAO of

$m$6

states. The proof passes to the interior sequence $m$7, which records the state of the original DFAO rather than its output. On input $m$8, the new automaton remembers the block

$m$9

together with the last bits of the codes of $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$0. Using the subword-complexity bound of Lemma 1, this yields $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$1 possibilities for the state block and $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$2 possibilities for the last-bit patterns, hence $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$3 in total (Moradi et al., 23 Mar 2026).

For the Fibonacci-Thue–Morse sequence $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$4, the shifted sequence $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$5 can be generated by a minimal DFAO of

$m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$6

states. The argument uses the fact that the difference of bit-counts over windows of length $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$7 grows only linearly (Moradi et al., 23 Mar 2026). This is a special-case improvement over the general $m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$8 bound.

The central subsequence result concerns

$m \;=\;\sum_{i=2}^t e_i\,F_i,\qquad e_i\in\{0,1\},$9

for fixed $e_i e_{i+1}=0$0 and $e_i e_{i+1}=0$1. If $e_i e_{i+1}=0$2 is generated by an $e_i e_{i+1}=0$3-state DFAO, then this linear subsequence is generated by a DFAO of

$e_i e_{i+1}=0$4

states. The construction first builds an unambiguous FSA (UFAO) that, on input $e_i e_{i+1}=0$5, guesses $e_i e_{i+1}=0$6 such that $e_i e_{i+1}=0$7 and simulates $e_i e_{i+1}=0$8 on $e_i e_{i+1}=0$9. A subset construction then yields a DFAO whose states are characterized by

$(e_t e_{t-1}\dots e_2)$0

where $(e_t e_{t-1}\dots e_2)$1 and $(e_t e_{t-1}\dots e_2)$2. The factor comes from

$(e_t e_{t-1}\dots e_2)$3

with each coordinate automatic. By Lemma 1 there are $(e_t e_{t-1}\dots e_2)$4 such factors and $(e_t e_{t-1}\dots e_2)$5 choices for $(e_t e_{t-1}\dots e_2)$6, giving $(e_t e_{t-1}\dots e_2)$7 (Moradi et al., 23 Mar 2026).

A plausible implication is that subsequence extraction in Fibonacci numeration is governed less by ad hoc algebraic identities than by the automaton growth induced by difference tracking and determinization.

4. Morphic generation and the Bosma–Don improvement

A standard morphic presentation of an automatic sequence treats each DFAO state as a letter and defines a morphism sending each state $(e_t e_{t-1}\dots e_2)$8 to the block of states reached on input letters. The size of the morphism is the sum of the lengths of all images (Moradi et al., 23 Mar 2026).

Bosma and Don proved an exponential upper bound on the size of a morphism generating $(e_t e_{t-1}\dots e_2)$9, where $i$00 is the Fibonacci word. As an immediate corollary of the $i$01 subsequence construction, for each $i$02, $i$03, and any Fibonacci-automatic $i$04, there is a polynomial-size morphism of size

$i$05

which generates the subsequence $i$06. In particular, the previously exponential bound for the Fibonacci word itself collapses to $i$07 (Moradi et al., 23 Mar 2026).

This improvement is significant because it converts a general existence statement with exponential overhead into a polynomially bounded construction. Within the article’s scope, that is the principal complexity-theoretic consequence of the automaton bounds for linear subsequences.

5. Constructive complexity through Büchi arithmetic

The constructive side of the theory is formulated through a reasonable interpretation of Büchi arithmetic. In practice, software such as Walnut encodes Zeckendorf arithmetic in Büchi-decidable first-order logic over $i$08 with addition and automatically carries out product constructions, projections, and minimizations. The complexity analysis is measured in the total number of transition-traversals needed to build the corresponding automata (Moradi et al., 23 Mar 2026).

Construction task	Resulting runtime
DFA for $i$09	$i$10
DFA for $i$11	$i$12
DFA for $i$13	$i$14
DFA for $i$15	$i$16
DFAO for $i$17	$i$18

For $i$19, the canonical representation of $i$20 has length $i$21, and the minimal DFA has $i$22 states. The same asymptotic runtime extends to $i$23 by combining the fixed-constant addition machine with the equality construction (Moradi et al., 23 Mar 2026).

The multiplication relation $i$24 is more delicate. The construction uses a recursion on $i$25, separating even and odd cases, followed by product-and-projection operations. For fixed $i$26, this yields a DFA for $i$27 in

$i$28

time, and the same asymptotic bound applies to $i$29 (Moradi et al., 23 Mar 2026).

Finally, given an $i$30-state DFAO for $i$31, one takes the product with the automaton for $i$32, projects away the second input, determinizes, and minimizes. The resulting algorithm computes a DFAO for $i$33 in

$i$34

time (Moradi et al., 23 Mar 2026).

The surrounding literature shows the same logic-to-automaton pipeline in other Fibonacci settings. In the study of Wythoff sumsets, Walnut formulas using the ?msd_fib directive define sets such as $i$35, $i$36, and $i$37, and the resulting automata expose finite or co-finite complements (Shallit, 2020). In the study of A105774, Walnut is used to verify that a guessed synchronized automaton defines a total function and satisfies the defining recurrence, with the corresponding queries returning TRUE (Cloitre et al., 2023).

6. Related automatic structures and conceptual boundaries

The broader literature on Fibonacci representations clarifies how Fibonacci-automatic sequences interact with additive combinatorics and synchronized recursion. In one direction, the lower and upper Wythoff sequences are characterized by suffix conditions on $i$38: $i$39 iff $i$40 ends in $i$41, and $i$42 iff $i$43 ends in $i$44. Walnut then constructs small automata for complements of sumsets such as $i$45, $i$46, and $i$47, with sizes ranging from $i$48 to $i$49 states; for example, the complement of $i$50 is recognized by a $i$51-state automaton and consists of the numbers $i$52 (Shallit, 2020). The same work states that once an automaton for a sumset $i$53 is available, one can derive linear representations, of rank up to $i$54 in the hardest case, to count $i$55 in time $i$56 (Shallit, 2020).

In another direction, synchronized Fibonacci automata capture recursively defined sequences whose values are not merely finite outputs attached to states. For OEIS A105774, a synchronized DFA recognizing the graph of $i$57 yields a DFAO with $i$58 states, and Walnut verifies both functionality and the defining recurrence. The same paper proves two decidability results: if $i$59 and $i$60 are synchronized Fibonacci sequences, then it is decidable whether $i$61 is a permutation of $i$62; and given synchronized sequences $i$63 and $i$64, it is decidable whether $i$65 is the distinctness-transform of $i$66 (Cloitre et al., 2023).

These neighboring results delimit several common misconceptions. First, Fibonacci-automaticity is not restricted to isolated toy examples: it supports explicit constructions for arithmetic relations, sumsets, and recursively defined sequences. Second, synchronization is not the same as ordinary automaticity; it is described as strictly more powerful because it recognizes graphs of functions rather than only finite-state outputs (Cloitre et al., 2023). Third, the complexity growth for linear subsequences in Fibonacci numeration need not be exponential: the subsequence automata admit the polynomial bounds $i$67 for DFAO size and $i$68 for associated morphism size (Moradi et al., 23 Mar 2026).

Taken together, these results place Fibonacci-automatic sequences at the intersection of numeration systems, automata theory, morphic generation, and algorithmic logic. The specific contribution of the linear-subsequence complexity analysis is to make that intersection quantitative: it assigns explicit state bounds to arithmetic relations, explicit DFAO bounds to subsequence constructions, and explicit runtime bounds to the logical procedures that build the automata.