User Rating 0.0 ★★★★★

Total Usage 0 times

Category Number Generators

Start Index (n) 0 ≤ n ≤ 99,999

Number of Terms 1 ≤ count ≤ 10,000

Presets:

Configure parameters and press Generate to compute the Baum-Sweet sequence.

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

The Baum-Sweet sequence, introduced by L. E. Baum and M. M. Sweet in 1976, is a binary-valued sequence indexed by non-negative integers. For each n, the term b(n) equals 1 if and only if the binary expansion of n contains no block of consecutive zeros whose length is odd. Otherwise b(n) = 0. The sequence begins 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1 (OEIS A086747). It arises in the study of algebraic power series over finite fields and connects number theory to formal language theory. Misidentifying zero-block parity leads to incorrect classification of algebraic irrationals over F₂. This generator computes exact values and exposes the binary structure so you can verify each term against its zero-run decomposition.

Formulas

The Baum-Sweet sequence is defined by inspecting the binary representation of each non-negative integer for contiguous runs of zeros.

b(n) = {

1 if n = 01 if every maximal block of consecutive zeros in bin(n) has even length0 otherwise

Where bin(n) denotes the binary string of n without leading zeros. A maximal block is a contiguous substring of 0s not extendable left or right. The algorithm scans this string with a regular expression matching pattern 0+ to extract all zero runs, then checks the length parity of each.

Equivalently, b(n) = 1 if and only if n can be written as n = k∑i=0 a_i ⋅ 4^c_i where each a_i ∈ {1, 2, 3} and c_i are distinct non-negative integers. This base-4 characterization proves no digit equals 0 in the base-4 representation.

Where: b(n) = the Baum-Sweet term at index n; bin(n) = binary representation of n; a_i = base-4 digits of n.

Reference Data

n	Binary	Zero Runs	b(n)
0	0	-	1
1	1	none	1
2	10	1 (odd)	0
3	11	none	1
4	100	2 (even)	1
5	101	1 (odd)	0
6	110	1 (odd)	0
7	111	none	1
8	1000	3 (odd)	0
9	1001	2 (even)	1
10	1010	1, 1 (odd)	0
11	1011	1 (odd)	0
12	1100	2 (even)	1
13	1101	1 (odd)	0
14	1110	1 (odd)	0
15	1111	none	1
16	10000	4 (even)	1
17	10001	3 (odd)	0
18	10010	2, 1 (odd)	0
19	10011	2 (even)	1
20	10100	1, 2 (odd)	0
21	10101	1, 1 (odd)	0
22	10110	1, 1 (odd)	0
23	10111	1 (odd)	0
24	11000	3 (odd)	0
25	11001	2 (even)	1
26	11010	1, 1 (odd)	0
27	11011	1 (odd)	0
28	11100	2 (even)	1
29	11101	1 (odd)	0
30	11110	1 (odd)	0
31	11111	none	1

Frequently Asked Questions

The convention follows the original 1976 paper by Baum and Sweet. The value n = 0 is treated as a special case: its binary representation is considered to have no zero blocks (since there is no non-trivial binary expansion). Equivalently, in base-4, 0 has no digits at all, satisfying the condition vacuously. Every standard reference (OEIS A086747, Allouche & Shallit) sets b(0) = 1.

A zero run of even length 2k in binary corresponds to a factor of 4^k, which is absorbed into the base-4 digit structure. A zero run of odd length would require a base-4 digit of 0 (since an isolated 0 bit cannot pair with an adjacent 0 to form a complete base-4 digit). Therefore b(n) = 1 if and only if no base-4 digit of n equals 0. This gives an O(log n) algorithm: convert to base 4 and check for any 0 digit.

The density of 1s tends to 0. More precisely, the number of indices k ≤ n with b(k) = 1 grows as O(n^(log 3 / log 4)) ≈ O(n^0.7925). This sub-linear growth means 1s become increasingly sparse. The exponent log₄(3) arises because in base 4, each digit has 3 out of 4 non-zero choices, giving 3^d valid numbers with d digits.

Yes. The Baum-Sweet sequence is 2-automatic, meaning it can be generated by a deterministic finite automaton with output (DFAO) reading the base-2 digits of n. The automaton has 3 states: state 0 (start, output 1), state 1 (inside even-length zero run, output 1), and state 2 (trap, output 0). Transitions: from state 0, reading 1 stays at 0, reading 0 goes to 1. From state 1, reading 0 goes to 0, reading 1 goes to 0. From state 2, all inputs stay at 2. State 1 reading 1 goes to 0 (even zero block closed), but if state 1 reads end-of-input, output 0 (odd zero block). The exact automaton varies by formulation but the sequence is provably 2-automatic.

Baum and Sweet proved that the generating function f(x) = Σ b(n)·x^n satisfies the cubic equation f³ + x·f + 1 = 0 over the field F₂. This means f(x) is algebraic of degree 3 over F₂(x). The sequence was originally constructed to study the continued fraction expansion of algebraic elements in the field of formal Laurent series over F₂. It demonstrated that algebraic irrationals over finite fields can have bounded partial quotients, contrasting with open conjectures for real algebraic irrationals.

Each term requires converting n to binary (O(log n) time) and scanning for zero runs (O(log n) time). For 10,000 terms the total work is roughly 10,000 × 17 bits ≈ 170,000 character operations. This completes in under 50ms on modern hardware. The generator caps at 10,000 terms per batch to keep the DOM responsive. For individual lookups, any n up to 2^53 − 1 (JavaScript safe integer limit) works correctly.