Is the Fibonacci constant $0.11235813213455...$ a normal number?

Question

Recall that a normal decimal number is an irrational number $\alpha \in \mathbb{R}$ such that each digit 0-9 appears with average frequency tending toward $\frac{1}{10}$, each pair of digits 00-99 appears with average frequency tending toward $\frac{1}{100}$ in the decimal expansion of $\alpha$, etc.

Since the Champernowne constant $$0.12345678910111...$$ obtained by concatenating natural numbers is known to be normal, and since the Copeland-Erdős Constant $$0.23571113171923...$$ obtained by concatenating prime numbers is known to be normal, and since the Besicovitch constant $$0.14916253649648...$$ obtained by concatenating the squares of natural numbers is known to be normal, it is natural to consider whether or not the "Fibonacci constant" $$0.11235813213455...$$ obtained by concatenating consecutive entries in the Fibonacci sequence is normal in base $10$.

This problem has been considered previously in the linked arXiv article, although the "proof" given in this article is erroneous. So it is natural to ask:

(1) Is the Fibonacci constant $0.11235813213455...$ normal in base $10$?

(2) Is the Fibonacci constant $0.11235813213455...$ known to be normal in base $10$?

Answer 1

On Edit: code completely revised (and now debugged!)

It is an interesting question. The answer is probably "yes", though I have no idea how to prove it.

It can't hurt to write a program to explore it. Here is a simple Python3 function to explore the digit-block distributions:

import statistics

def fibConst(n):
    #Generator for first n digits of the Fibonacci constant
    F1 = 0
    F2 = 1
    pool = list(str(F2))
    pool.reverse() #list of digits in reversed order
    for i in range(n):
        if len(pool) == 0:
            F1,F2 = F2, F1+F2
            pool = list(str(F2))
            pool.reverse()
        yield int(pool.pop())

def digitDist(n,k = 1, summary = True):
    #returns the distribution of the k-digit blocks
    #first n digits of the Fibonacci constant
    #.1123581321...
    #if summary = True (the default)
    #a statistical summary is returned:
    #(min, max, median, mean, standard deviation)
    #otherwise, the whole distribution is returned as a list

    counts = [0] * 10**k
    digits = fibConst(n)

    num = 0
    for i in range(k):
        num = 10*num + next(digits)
    counts[num] = 1 #record initial block of length k

    for i in range(k,n):
        num = (10 * num + next(digits)) % 10**k
        counts[num] += 1

    if not summary:
        return counts
    else:
        minCount = min(counts)
        maxCount = max(counts)
        med = statistics.median(counts)
        m = statistics.mean(counts)
        sd = statistics.pstdev(counts)
        return (minCount,maxCount,med,m,sd)

The first function is a generator (aka lazy list) which produces successive digits on demand. It doesn't attempt to keep the full n digits in memory.

Typical runs:

>>> for k in range(1,6): print(digitDist(10**6,k))

(99445, 100743, 100013.0, 100000.0, 351.6694470664178)
(9819, 10245, 10002.0, 9999.99, 91.5220732938235)
(894, 1096, 1000.0, 999.998, 31.575560105879358)
(61, 142, 100.0, 99.9997, 10.070278045317318)
(0, 28, 10.0, 9.99996, 3.1738399453028503)

>>> for k in range(1,7): print(digitDist(10**7,k))

(997286, 1003133, 999964.0, 1000000.0, 1490.5531188119396)
(99373, 100868, 100014.5, 99999.99, 322.87339608583426)
(9650, 10363, 10001.5, 9999.998, 98.10266049399476)
(890, 1140, 1000.0, 999.9997, 31.520718581751908)
(56, 143, 100.0, 99.99996, 9.967519249963855)
(0, 28, 10.0, 9.999995, 3.1578519597940304)

While this data seems to on the whole support the conjecture that the number is normal, the bottom lines of these runs are both surprising. When you look at the first million digits some 5-digit sequences appear not at all and some appear 28 times. A bit of sleuthing uncovered that the sequence 24242 appeared zero times and the sequence 48087 appeared 28 times. I don't now what to make of this, though it is enough to make me a little more hesitant in conjecturing normality.

Final remark: if you want a string representation of the initial part of the constant you can write a function like:

def strFib(n):
    return '0.' + ''.join(str(d) for d in fibConst(n))

For example,

>>> strFib(20)
'0.11235813213455891442'
>>> strFib(100)
'0.1123581321345589144233377610987159725844181676510946177112865746368750251213931964183178115142298320'