Abstract 1 Introduction 2 Combinatorial Properties of 𝑳𝒒 3 𝑳𝒒 Is Not Context-Free 4 𝑳𝒒 Cannot Be Recognised by Certain Constant-Depth Circuits 5 Open Questions References

Languages of Words of Low Automatic Complexity Are Hard to Compute

Joey Chen Department of Mathematics, National University of Singapore, Singapore Bjørn Kjos-Hanssen ORCID Department of Mathematics, University of Hawai‘i at Mānoa, Honolulu, HI, USA Ivan Koswara ORCID School of Computing, National University of Singapore, Singapore Linus Richter111Corresponding author ORCID Department of Mathematics, National University of Singapore, Singapore Frank Stephan ORCID Department of Mathematics, National University of Singapore, Singapore
School of Computing, National University of Singapore, Singapore
Abstract

The automatic complexity of a finite word (string) is an analogue for finite automata of Sipser’s distinguishing complexity (1983) and was introduced by Shallit and Wang (2001). For a finite alphabet Σ of at least two elements, we consider the non-deterministic automatic complexity given by exactly – yet not necessarily uniquely – accepting automata: a word xΣ has exact non-deterministic automatic complexity k if there exists a non-deterministic automaton of k states which accepts x while rejecting every other word of the same length as x, and no automaton of fewer states has this property. Importantly, and in contrast to the classical notion, the witnessing automaton may have multiple paths of computation accepting x. We denote this measure of complexity by ANe, and study a class of languages of low ANe-complexity defined as Lq={xΣ:ANe(x)<q|x|}, which is parameterised by rationals q(0,1/2) (generalising a class of sets first studied by Kjos-Hanssen). We show that for every q(0,1/2), this class is neither context-free nor recognisable by certain Boolean circuits. In the process, we answer an open question of Kjos-Hanssen quantifying the complexity of L1/3 in terms of Boolean circuits, and also prove the Shannon effect for ANe.

Keywords and phrases:
Automatic complexity, automata theory, formal languages, Boolean circuits, Shannon effect
Funding:
Bjørn Kjos-Hanssen: This work was partially supported by a grant from the Simons Foundation (#704836 to Bjørn Kjos-Hanssen).
Linus Richter: This work was fully supported by Singapore Ministry of Education grant MOE-000538-01.
Frank Stephan: This work was partially supported by Singapore Ministry of Education grant MOE-000538-01.
Copyright and License:
[Uncaptioned image] © Joey Chen, Bjørn Kjos-Hanssen, Ivan Koswara, Linus Richter, and Frank Stephan; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Grammars and context-free languages
; Theory of computation Regular languages
Related Version:
Full Version: https://doi.org/10.48550/arXiv.2510.07696 [4]
Acknowledgements:
Parts of this work have appeared in the first author’s Bachelor’s thesis submitted to the National University of Singapore.
Editors:
C. Aiswarya, Ruta Mehta, and Subhajit Roy

1 Introduction

Automatic complexity is a notion of complexity of finite words (strings) determined by witnessing automata, first introduced by Shallit and Wang in [35] as a Turing computable alternative to Kolmogorov complexity. It is an analogue for finite automata of Sipser’s distinguishing complexity [37]. Classically, the automatic complexity of a word x over a finite alphabet Σ refers to the cardinality – counted in number of states333A version of automatic complexity counting the number of transitions has been studied by Serna [32]; see also Shallit and Breitbart [34]. – of the smallest deterministic finite automaton which accepts x and rejects every other word of the same length as x [35]. The notion as well as variations of it have proven interesting for multiple reasons. For instance, since automatic complexity is Turing computable, it can be used in the study of computational complexity: the computational complexity of sets of binary words of low automatic complexity has helped prove missing relationships in the Complexity Zoo [1] (see [20, Theorem 39] for an example). Further, the detailed investigation of words in terms of their automatic complexity [17, 16] has shed light on computable notions of randomness, which are unavailable from the viewpoint of Kolmogorov complexity [21, 40, 28].

In this paper, we study a weakening of a variation of automatic complexity due to Hyde [12], and show that it generates classes of words too complicated to be captured by pushdown automata, nor by certain classes of constant-depth Boolean circuits – both of which are notably computationally more powerful than finite automata. This provides further evidence towards the conjecture that automatic complexity is hard to compute (see e.g. [15]).

1.1 Technical Background

Fix a finite alphabet Σ of at least two elements. In usual Kleene notation, we denote by Σ the set of all finite words of elements from Σ. We denote the empty string by ε, and the set of non-empty words by Σ+=Σ{ε}. By an automaton we always mean a non-deterministic finite automaton, unless otherwise stated. We do not allow ε-transitions.

Definition 1.

Let xΣ. An automaton M exactly accepts x if M accepts x, and whenever both yx and |y|=|x| then M rejects y.

The pumping lemma shows that this definition is maximally restrictive on the number of words accepted by the witnessing automaton; trying to strengthen the definition by asking for outright uniqueness of the accepted word only leads to trivialities.

Definition 2.

The automatic complexity of xΣ is given by

AD(x)=min{k:there exists a DFA of k states which exactly accepts x}.

For a reference on contemporary automatic complexity, see e.g. the recent [19]. The subscript D stands for “deterministic”, indicating that AD(x) is determined by the smallest DFA. By definition, it is clear that AD is well-defined, and even computable (for every n, there are only finitely many DFAs, and each can be simulated in finite time). However – similar to the unnatural properties of plain compared to prefix-free Kolmogorov complexity – the measure AD has the following properties, which may render it undesirable as a natural measure of complexity of words. These were first described in [13]:

  1. 1.

    AD is not invariant under natural transformations on strings, such as reversals. For instance, Hyde and Kjos-Hanssen have verified computationally that AD(011100)=4<5=AD(001110).

  2. 2.

    The DFA witnessing AD(x) often appears unnatural, in the sense that determinism requires AD(x) to be total: in many cases, an automaton non-“deterministically” witnessing AD(x) needs to be augmented by an extra state to which every non-accepting path leads.

To overcome these obstacles, Hyde introduced automatic complexity witnessed by the smallest non-deterministic finite automaton (NFA) [12].

Definition 3.

Let xΣ. An automaton M uniquely accepts x if M exactly accepts x and there is only one path in M which accepts x.

Clearly, every DFA which exactly accepts x also uniquely accepts x. For NFAs, however, this is not the case. An NFA uniquely accepts x if and only if the NFA exactly accepts x and the NFA is unambiguous on Σ|x|. Though Hyde [12] required the NFA to be unambiguous on Σ|x|, she noted that the complexity based on NFAs is much more flexible and many words have a smaller complexity in her version than if only DFAs are considered. This led her to:

Definition 4.

Let xΣ. The unique non-deterministic automatic complexity of x is given by

AN(x)=min{k:there exists an NFA of k states which uniquely accepts x}.
 Remark 5.

We note that this notion is usually called “non-deterministic automatic complexity”. As we study an ostensibly weaker notion below, we emphasise the additional strength of the notion defined in Definition 4 by adding the attribute “unique”.

While it is well-known that NFAs and DFAs recognise exactly the same class of languages – the regular languages (see e.g. [33, 14] for a comprehensive background on automata theory) – the respective notions of automatic complexity differ. The following properties of AN have been derived by Hyde and Kjos-Hanssen alongside co-authors, and others. Let MN(x) denote both the minimal automaton witnessing AN(x) and the directed graph representing it.

Lemma 6.

Let xΣ.

  1. 1.

    AN(x)(|x|/2)+1 follows from exhibiting suitable NFAs [12].

  2. 2.

    MN(x) is planar [2].

Building upon Hyde’s work from [12], in the present paper we study more closely the notion of automatic complexity induced by a weaker class of machines: the class of exactly but not necessarily uniquely accepting automata.

Definition 7.

Let xΣ. The non-deterministic automatic complexity of x is

ANe(x)=min{k:there exists an NFA of k states which exactly accepts x}.

Since every NFA which uniquely accepts x also exactly accepts x, we have ANe(x)AN(x). Whether equality holds is still open (Question 48). In [20], Kjos-Hanssen investigated the complexity of certain languages induced by AN in terms of more complicated models of computation, e.g. pushdown automata. In particular, he showed:

Theorem 8.


  1. 1.

    {x{0,1,2}:AN(x)|x|/2} is not context-free.

  2. 2.

    {x{0,1}:AN(x)|x|/3} cannot be recognised by constant-depth circuits with semi-unbounded fan-in, using Boolean - and -gates.

Results of this type motivate this paper: we investigate the impact of exactness on the behaviour of automatic complexity, which we describe via theorems akin to Theorem 8.

1.2 Our Theorems and the Structure of This Paper

We investigate the complexity of ANe as a function in terms of the complexity of the language of ANe-complicated words. Explicitly, we investigate the following class of languages first defined444In [20, Def. 17], Kjos-Hanssen has considered the complementary decision problem, given by q|x|<ANe(x). We note that our class {Lq:q(0,1/2)} is more general. by Kjos-Hanssen [20], and prove results on their complexities.

Definition 9.

For q(0,1/2), define Lq={xΣ:ANe(x)<q|x|}.

In Section 2, we isolate complexity results on the Lq-sets which follow from a fine-grained investigation of its elements. For instance, in Proposition 17 we isolate an upper bound of the Kolmogorov complexity of words in Lq. This gives a small-to-large result – a theorem about elements which provides information about sets – in the form of Corollary 19, which shows that the cardinality of LqΣn is in o(|Σ|n). This observation also yields a proof of the Shannon effect for ANe:

Theorem 22.

Let ANe(Σn)=maxxΣnANe(x). For almost every xΣ we have

ANe(x)ANe(Σ|x|)o(ANe(Σ|x|)).

In Section 3, we show that pushdown automata are not powerful enough to characterise ANe-complicated words, which the following theorems show.

Theorem 34.

For every q(0,1/2), the language Lq is not context-free.

Theorem 35.

For every q(0,1/2), the language ΣLq is not context-free.

In Section 4, we consider the complexity of Lq in terms of Boolean circuits. To do so, we use two classical types of Boolean circuits – 𝐒𝐀𝐂0, defined in Section 4.1, and 𝐒𝐀𝐂0, defined in Section 4.2 – and apply a counting argument to prove:

Theorem 39.

Let q(0,1/2) and |Σ|=2. Then Lq𝐒𝐀𝐂0 and ΣLq𝐒𝐀𝐂0.

Theorem 46.

Let q(0,1/2) and |Σ|=p for some prime p. Then Lq𝐒𝐀𝐂0 and ΣLq𝐒𝐀𝐂0.

As a special case, we show that L1/3 is not 𝐒𝐀𝐂0-recognisable, answering a question of Kjos-Hanssen [20, p. 351]. Omitted proofs as well as a partial generalisation to alphabets of non-prime cardinality can be found in the related full version of this paper [4].

In Section 5, we conclude this paper by giving a few open questions.

2 Combinatorial Properties of 𝑳𝒒

In this section, we derive combinatorial properties of Lq which are needed in the sequel, particularly to prove Theorem 34. Fix q(0,1/2). Firstly, we show that Lq satisfies a strong closure property: any word xΣ can be extended to some word yΣ for which yLq.

Proposition 10.

Suppose xΣ. If m>|x|/q then xmLq.

Proof.

Let n=|x| and suppose x=x0xn1Σ. Now build an NFA as follows: there are n states {s0,,sn1}, with s0 being both the start and unique accepting state. Transitions are given by sixisi+1 for i<n1 and sn1xn1s0. It is readily seen that this automaton witnesses ANe(xm)|x|<qm<qm|x|=q|xm|, as needed. While the previous proposition employs repetition of words to push the non-deterministic automatic complexity down, in the following lemma we show that spacing out bits of information achieves the same effect. W.l.o.g., assume 0Σ. For notation, if x=x0xn1Σ then define the (Hamming) weight of x by weight(x)=|{k<n:xk0}|.

Lemma 11 (Gap Lemma).

For every c there exists n such that if xΣn and weight(x)c then xLq.

Note that, in the statement above, n depends on q, which we fixed at the beginning of this section. Before we give the proof, we need the following number-theoretical lemma, called Bertrand’s postulate (for a proof see e.g. [29]). Let denote the set of prime numbers.

Lemma 12 (Bertrand’s postulate).

If h>1 then (h,2h) is non-empty.

Proof of Lemma 11.

Fix c. For each n{0,1}, we define a finite sequence of primes by (p1(n),,pc(n)) as follows: put p1(n)=min((nc,2nc)) and

pi+1(n)=min((pi,2pi)) for i=1,2,,c1.

Since n>1, Bertrand’s Postulate shows that this is well-defined. Now, let

Qi(n)=(1pi(n))j=1cpj(n)

Bertrand’s postulate alongside a short calculation implies pc(n)<2c1p1(n)<2cnc, and so

Qi(n)(pc(n))c12c(c1)nc1c

which proves that Qi(n)O(nc1c). This also shows that, in the limit, Qi(n)<n. Similarly, Qi(n)pi(n)>(p1(n))c>(nc)c=n and hence, again in the limit, Qi(n)<n<Qi(n)pi(n). For xΣn with weight(x)c, write x=w001w10kwk for some kc. Given our fixed q(0,1/2), we now choose n sufficiently large so that we may assume the following (write Qi=Qi(n)):

  • |wi|cQ1 for i=0,1,,k.

  • iQ1 for i=1,,k.

Now, write i=aiQi+ri where 0ri<Qi. Since Qipi>n we must have ai<pi; otherwise, |i|>n=|x|, a contradiction. Hence, consider the automaton M in Figure 1.

Figure 1: The non-deterministic automaton witnessing the “gap lemma”.

We show that M is as required. First, by definition, M accepts x. To show exactness, suppose yΣn and that M accepts y. If xy, assume w.l.o.g. that M(y) traverses the 0Q1-loop fewer than ai-many times. Since |y|=n, M(y) must go through the remaining loops more often to make up for the Q1-deficit. However, the equation Q1=d2Q2++dkQk has no integer solution, since p1 divides the right-hand side yet not Q1. Thus, M cannot accept y, as needed. Finally, recall that ri,|wi|cQ1O(nc1c). Thus, for n large enough, inspection of the automaton M shows that ANe(x)3kcQ1O(nc1c) for every xΣn, and so ANe(x)<q|x|. As a consequence of our proof, we also obtain the following (we thank the anonymous reviewer for pointing this out).

Corollary 13.

For every c and every q(0,1/2) there exists n such that if xΣ>n and weight(x)c then xLq.

Our next result studies the small-scale structure of words in Lq. We say w is a factor of x if there exist u,vΣ for which x=uwv; we write wx. If uΣ+ or vΣ+ then w is a proper factor of x; we write wx. Call a non-empty word w a square if there exists vw for which w=vv; we write w=v2.

Proposition 14.

Let n4 and xLqΣn. There exists a proper factor wx of length |w|(12q2)n for which there are u,vΣ+ with |u|=|v||w| and uw=wvx. Further, uwvx.

Note that if |u|=|v|=|w| then the conclusion of Proposition 14 yields a square. To prove the general case of Proposition 14, we again need a classical auxiliary result, in this case due to Lyndon and Schützenberger [27].

Theorem 15 (The First Lyndon-Schützenberger-Theorem).

Suppose x,yΣ. Then xy=yx if and only if there exists zΣ and k, for which x=zk and y=z.

Note that the First Lyndon-Schützenberger-Theorem characterises bordered words555For more on bordered words, see e.g. [30]. A more general characterisation is given by the Second Lyndon-Schützenberger-Theorem 18. – those which have a non-trivial decomposition of the form uw=wv – as those generated by powers of a common word z. This will be important in the proof of Proposition 14. We also require the following combinatorial lemma.

Lemma 16.

Suppose xΣn for some n4. Assume xLq, and let MNe(x) be the witnessing automaton with accepting run (q0,,qn). Then

|{k:(i,j)(i<j<kqi=qj=qk)}|(12q)n.

Proof.

Consider the list of states (q0,,qn). Since q<1/2, we have 2qn<n. In particular, n=2qn+(12q)n. Hence, by the pigeonhole principle, there exist at least (12q)n indices at which some state is visited a third time. We now prove Proposition 14. Call triples (i,j,k) as provided by Lemma 16 loop triples (for x). Before we give the proof of Proposition 14, we introduce the following notation: write x[i,j]=xixj. For instance, if n4, then x0x1xn1=x[0,n1]=x[0,2]x[3,n1].

Proof of Proposition 14.

Let xΣn be as assumed, and suppose (q0,,qn) is the run of MNe which accepts x. Observe that if (i,j,k) is a loop triple for x (by Lemma 16 there are at least (12q)n many), then the witnessing NFA MNe(x) has completed at least two loops by the time it has read the word x[0,k1]. There are two cases.

  1. 1.

    There exists a loop triple (i,j,k) for which max(|x[i,j1]|,|x[j,k1]|)>(12q)n.
    Assume w.l.o.g. that |x[j,k1]||x[i,j1]| and write x=x[0,i1]x[i,j1]x[j,k1]x[k,n1]. Since (i,j,k) is a loop triple, qi=qj=qk, and thus MNe(x) also accepts the word x[0,i1]x[j,k1]x[i,j1]x[k,n1]. Since MNe(x) exactly accepts x, we have x[j,k1]x[i,j1]=x[i,j1]x[j,k1], and so Theorem 15 implies x[i,j1]=zk and x[j,k1]=z for some zΣ+ and k,. Since k,1, the decomposition of x[i,k1] trivialises into a product of copies of z:

    x[i,k1]=x[i,j1]x[j,k1]=zzk+1=zk+1z

    As |zk+1||x[j,k1]|(12q)n>(12q)n, we are done.

  2. 2.

    For all loop triples (i,j,k) we have max(|x[i,j1]|,|x[j,k1]|)(12q)n.
    By Lemma 16, there exist (12q)n indices k for which there exist (i,j) such that (i,j,k) is a loop triple. Since every loop in a loop triple has length at most (12q)n, the pigeonhole principle gives an (12q)n such that there exist at least mn such indices k at which a loop of length was just completed (hence, we only focus on the second loops in each loop triple). Let this set of indices be given in ascending order, denoted by 𝒦={k1,,km}, with associated loops ρ1,,ρmx, each of length .

    We show that ρ1 and ρm must be disjoint, i.e. share no states along their traversals in MNe(x). Let qk1 be the origin state of the loop ρ1. By definition, ρ1 is the second loop in the loop triple (i1,j1,k1). Suppose τ is the first loop at qk1 so that τρ1 is a loop triple at qk1. Then, if we read b>(12q)n letters along the loops at state qk1, then we could concatenate those loops with τ to obtain a loop triple, one of whose lengths exceeds (12q)n, which contradicts the assumption of this case. Therefore, at state qk1, we can only read at most (12q)n letters of the factors contained in ρ1,,ρm, before moving on to a different state, never to return. However, by construction, for every im we know that xki appears in ρi, and thus we must read at least mn letters throughout all loops ρ1,,ρm. Since q<1/2, we have (12q)n<nm; hence, the first and last loops ρ1 and ρm must be disjoint. Thus, x=uρ1yρmu where u,y,ux and |ρ1|=|ρm|=. By exact acceptance of MNe(x), we have

    x=u(ρ1)2yu

    since |ρ1|=|ρm|. Therefore, ρ1y=yρm, and thus, with y=ρ1y, we have yρm=ρ1y. To show that y has the desired length, note that yρm must contain the set {xk2,,xkm}; the loop ρ1, since it is the first loop in 𝒦, can only contain xk1. Since n4, we have

    |y|=|yρm||𝒦|1=m1n2n2.

We now apply Proposition 14 to go even finer: instead of studying the complexity of Lq, we classify the complexity of words in Lq, using plain Kolmogorov complexity. Fix an alphabet Σ of cardinality k, and let Ck denote the plain Kolmogorov complexity on words in Σ:

Ck(x)=min{(p):Uk(p)=x}.

where Uk is a universal Turing machine on the k-element alphabet. For details on Kolmogorov complexity, see e.g. [5].

Proposition 17.

If xΣnLq, then

Ck(x)n(12q)2n+5logk(n)+O(1).

Its proof – which is included in the full version [4] – requires an extension of Theorem 15, which gives a sufficient and necessary criterion for the decomposition of words with same prefix and suffix. As it will be useful to us in the sequel outside of the proof of Proposition 17, we state it right here in the version of [33].

Theorem 18 (The Second Lyndon-Schützenberger-Theorem).

Let x,y,zΣ. Then xy=yz iff there exist e{0}, uΣ+ and vΣ such that x=uv, z=vu, and y=xeu=uze.

With |Σ|=k as before, note that the function which maps xΣ to its Ck-witness is an injection. Hence, Proposition 17 immediately yields the following bound on |Lq|.

Corollary 19.

The set LqΣn has cardinality in o(|Σ|n).

From Corollary 19, we now deduce the Shannon effect for ANe. Originally conjectured by Shannon [36] and proven (and named) by Lupanov for Boolean functions [25, 26], the Shannon effect says that most strings are of almost maximal complexity. We give a definition due to Wegener [45].

Definition 20.

Let PΣ. We say that almost all x have property P if

limn|PΣn||Σ|n=1.
Definition 21.

Let Γ be a complexity measure defined on Σ. For n, let Γ(Σn)=maxxΣn(Γ(x)). Then Γ has the Shannon effect if for almost all xΣ we have

Γ(x)Γ(Σ|x|)o(Γ(Σ|x|)).

By exhibiting upper and lower bounds of complexity for all words, it is readily seen that (plain and prefix-free) Kolmogorov complexity satisfy the Shannon effect [21, 41, 42, 23, 22], as do AD [35] and An [12, 18]. The cardinality argument of Corollary 19 shows:

Theorem 22.

ANe satisfies the Shannon effect.

Proof.

Fix q=1/(2+ϵ) for some small ϵ>0. Since ANe(x)AN(x)(|x|/2)+1 (Lemma 6), identifying a suitable lower bound suffices. By Corollary 19, for o(|Σ|n)-many words xΣn we have xLq. Hence, for almost all (as per Definition 20) xΣn,

n2+ϵANe(x)n2+1

and so ANe(x)/|x| is sufficiently close to 1/2 for typical large x.

3 𝑳𝒒 Is Not Context-Free

Fix q(0,1/2) and suppose w.l.o.g. that 0,1Σ. In this section, we demonstrate that Lq cannot be generated by a context-free grammar (CFG); hence, Lq is not context-free. To this end, we first define the concept of a rich CFG. We then prove that if a CFG generates Lq, it must be rich. Finally, we show that any rich CFG generates words of arbitrarily high complexity, which contradicts the fact that the CFG generates Lq.

We provide the required definitions. (For more details, see e.g. [33].) A context-free grammar (CFG) is a tuple G=(VT,VN,S,P) where:

  • VT is the set of terminal symbols.

  • VN is the set of non-terminal symbols.

  • SVN is the start symbol.

  • P is a finite set of productions.

We also insist that VTVN=, and we define the set of symbols by V=VTVN. Elements of V are called sentential forms. Productions in P are pairs (A,γ) where AVN and αV. We denote such a production by Aγ.

The derivation relation is defined as follows: if α,βV then αβ if α=αAα′′ and β=αγα′′ for some α,α′′V, and there exists a production Aγ in P. The transitive and reflexive closure of is denoted by .

A language that is recognisable by a CFG is called a context-free language (CFL).

Definition 23.

A CFG has no useless nonterminals if:

  1. 1.

    each nonterminal is reachable from the starting symbol; and

  2. 2.

    a terminal string can be derived from each nonterminal.

Definition 24.

Let G be a CFG. A nonterminal AG is a rich nonterminal if for some words v,w,x,yΣ we have vwxyε and AvAxwAy as well as:

  1. 1.

    if vwε then vwwv; and

  2. 2.

    if xyε then xyyx.

A rich CFG has a rich nonterminal but no useless nonterminals. A rich CFL is generated by a rich CFG.

Our motivation for rich CFGs follows from Theorem 15, however, we note here that, in style, our richness characterisation is similar to classical results by Ginsburg [9, Theorem 5.5.1], who characterised boundedness of CFLs via syntactical properties of grammars. Our syntactical notion of richness, similarly, characterises the complexity of generated languages, in our case Lq. The equivalence in Theorem 15 implies that a rich non-terminal can construct words which do not collapse to repeating copies of a common factor z. This is needed in Section 3.2, where we construct high-complexity words.

3.1 Only Rich CFGs Can Generate 𝑳𝒒

We require the following normal form theorem due to Greibach [10] (see [11, p. 277] for a modern exposition).

Theorem 25 (Greibach Normal Form Theorem).

Every CFG with no ε-productions can be expressed in Greibach Normal Form: all its production rules are of the form AxA¯ where xΣ and A¯ is a finite word of nonterminals.

The following corollary is immediate.

Corollary 26.

Every CFL omitting ε is generated by a CFG in Greibach Normal Form.

Our main result in this subsection is the following.

Theorem 27.

If Lq is generated by a context-free grammar G, then G is rich.

Proof.

By our results in the previous section, Lq is non-empty; further, by definition, εLq. So, by Corollary 26, there exists a CFG G in Greibach Normal Form which generates Lq. We show that G must be rich by a counting argument on the number of nonterminals of G. Let k denote the number of nonterminals in G. Define

xi=0i14ki for i=1,2,,4k1.

By Proposition 10, for every i there exists mi for which ximiLq. Similarly, for each i there exists mi for which the derivation tree of ximi has a branch which contains some nonterminal A at least (4k)2+1 times. Let M be sufficiently large to satisfy these requirements for all xi simultaneously. By the pigeonhole principle, there exist i,j,4k1 such that some nonterminal A appears at least (4k)2+1 times in some branch of the derivation tree of each of xiM,xjM and xM.

Consider such a sufficiently long branch of the derivation tree of xiM, in which we choose to expand A at the end. Since G is in Greibach Normal Form, the derivation is of the form

Syi1yi2yi3yisAziszi3zi2zi1

from which xiM can be derived in at least (4k)2+1 expansions of A. Observe that each yijε, since G is in Greibach Normal Form. Consider the number of expansions of A in terms of blocks B1,B2,,Bn such that each block has cardinality 4k. By assumption, n4k+1. Let Am be the derivation of A from the expansions in block Bm. There are two cases:

  1. 1.

    For some mn, Am=yA with yΣ and666This is a consequence of the observation immediately following Theorem 25. |y|4k.

  2. 2.

    For all mn, Am=ymAzm with ym,zmΣ+. Then, A4k=yAz with |y|,|z|4k.

Since these two cases apply to all xiM,xjM and xM, two of them must share the same case above. W.l.o.g. assume both xiM and xjM fall into case 2 (the argument for case 1 is similar). Hence, TyAz (from the derivation of xiM) and TvAw (from the derivation of xjM) where |y|,|z|,|v|,|w|4k. By definition, y,z contain i zeroes, while v,w contain j zeroes among the first 4k letters. It is now seen from the First Lyndon-Schützenberger-Theorem that yvvy and zwwz. Hence, A is a rich nonterminal.

3.2 Every Rich CFG Generates High-Complexity Words

In this section, we prove that every rich CFG generates words of arbitrarily high complexity relative to its length. In particular, there exists a word x for which ANe(x)>q|x| for every q(0,1/2). This contradicts the fact that any rich CFG can generate Lq for any q, since any xLq satisfies ANe(x)<q|x|. We also isolate the following technical proposition.

Proposition 28.

Suppose u,vΣn with uvvu. Then the following set is infinite:

(u,v)={x{u,v}:if yx satisfies |y|>2log(|x|) then y occurs exactly once in x}

Proving Proposition 28 takes a few technical lemmas on the behaviour of non-commuting strings in formal languages. Denote the set of factors of wΣ by [w]={xΣ:xw}. For convenience, we now fix some n and a pair u,vΣn for which uvvu.

Lemma 29.

uv,vu[u3][v3]

Proof.

We give the argument for uv[u3]; the other parts are similar. Assume that uv[u3]; thus write u3=xuvy for some x,yΣ. Note that |xy|=|u|=|v|. Since uvvu we cannot have x,y{u,v}, and thus |x|,|y|<|u|=|v|. But now, by periodicity of u3, we must have xy=u. Thus u3=xyxyxy=xuvy. Therefore, uv=yxyx, from which it follows that u=xy=yx=v, contradicting the fact that uvvu. To motivate the next lemma, we provide the definition of string homomorphisms.

Definition 30.

A function h:{0,1,,n1}Σ is a string homomorphism if for all ni{0,1,,n1} we have h(n0nk)=h(n0)h(nk).

Observe that every such string homomorphism is uniquely defined by its action on the alphabet. Define a string homomorphism h:{0,1,2}{u,v} given by

h(0) =uv h(1) =vu h(2) =u3v4

With this string homomorphism fixed, the following lemma is immediate from Lemma 29.

Lemma 31.

u4,v4{[x]:xh({0,1})}

To give a proof of Proposition 28, we first code words as follows. For every k, let σk be the lexicographical concatenation of all positive integers which, coded in binary, have length k; each is then followed by a 2. For instance, σ2=002012102112. We consider the images of these words under h, and collect some immediate properties of the σk and the h(σk) below, whose proofs are readily deduced, hence omitted.

Lemma 32.

Let k.

  1. 1.

    |σk|=2k(k+1)

  2. 2.

    |h(σk)|=2k|v|(2k+7)

  3. 3.

    2log(|h(σk)|)2k+14|v| for sufficiently large k.

To prove Proposition 28, we show that for large enough k, every substring of h(σk) of length at least 2log|h(σk)| must contain two copies of h(2); since the word between any two copies of h(2) is unique within h(σk), the proposition is proven.

Proof of Proposition 28.

Fix k sufficiently large so as to satisfy Item 3, and consider the word h(σk). By construction and the choice of k, if yh(σk) and |y|2log(|h(σk)|) then y contains two copies of h(2). By definition, v4h(2); on the other hand, Lemma 31 shows that v4 cannot be a factor of any h(w) with w{0,1}. Hence, v4y must be a factor of some h(2) occurring in h(σk). We show that the copies of h(2) in y and in h(σk) overlap perfectly. Consider the word h(2)z=xh(2) contained in h(σk). This bordered word is in fact a proper square, which can seen by a case analysis on x. Write

x =a|u|+ for some a,0<|u|
u =αβ where |α|=
v =γδ where |γ|=

and note that this renaming implies |β|=|δ|, and that

h(2)z=xh(2)=x1x2(αβ)3(γδ)4=(αβ)3(γδ)4z.

There are four cases describing x1; using Theorems 15 and 18, each will lead to a contradiction.

  1. 1.

    a=0: Since |α|=, this case implies αβ=βα. Further, |βγ|=|αβ|=|βα|, and so α=γ. By comparing lengths, it is easily seen that β=δ, and so u=αβ=γδ=v, a contradiction.

  2. 2.

    a=1: Since u=αβ, by comparing initial segments it is readily seen that in this case uvv4, contradicting Lemma 29.

  3. 3.

    a=2 or a=3: Since xh(2)=h(2)z, we have |x|=|z|. So, if a=2,3, then again by comparing initial segments it is readily seen that uvv4, contradicting Lemma 29.

  4. 4.

    a>3: Here, v4z. Since z=h(w) for some w{0,1}, Lemma 29 gives a contradiction.

Hence, the copies of h(2) appearing in y are exactly those appearing in h(σk). But now, if yh(σk) is of length at least 2log(|h(σk|), then it contains a factor of the form h(2)ρh(2) where ρh({u,v}). Each such ρ appears only once in h(σk), by construction. Thus, for large enough k, the word h(σk) is as required, and thus the set (u,v) is infinite.

Theorem 33.

If G is a rich CFG, then G generates a word xΣ such that ANe(x)>q|x| for every q(0,1/2).

For notation, if σ{0,1}, let σ¯ denote the reverse of σ. Further, if x,yΣ satisfy xz=zy and both xz,zyw such that xz and zy overlap at z, then call xzy its union, written as xzzy. We use Proposition 28.

Proof.

Let G be a rich CFG with rich nonterminal A and witnesses x,y,x,yΣ for which AxAyxAy and xxxx and yyyy. Define u1=xx,v1=xx and u2=yy,v2=yy. Now define string homomorphisms g,h by:

g(0) =u1v1 g(1) =v1u1 g(2) =u13v14
h(0) =u2v2 h(1) =v2u2 h(2) =u23v24

Now, fix any w1,w2,w3Σ for which

Sw1Aw3 and Aw2. ()

By repeated application of the generation rules in (), it is readily seen that for any m,k, the word ym,k of the following form is generated by G:

ym,k=(w1g(σk))(xmw2ym)(h(σk)¯w3).

We show that, for sufficiently large m,k, the word ym,k has large non-deterministic automatic complexity. Choose m,k large enough so that |ym,k||w1w2w3|, and let n=|ym,k|. Since we may choose k,m freely, we may also impose that

2log(n)m|x|3log(n)o(n). ()

Now, let zym,k whose length is in O(n) be the first occurrence of a word in ym,k of the form zb=cz for words b,cym,k. Below, we show that this is only possible if b=c=ε.

By choosing m,k wisely, we may assume that |z| is even. Further, it will be convenient to distinguish the words which make up the left-hand and right-hand squares of z; hence, write z=z1z2=z1z2 so that |z1|=|z2| and z1=z1,z2=z2, and z1z2b=cz1z2.

We show that z1w1g(σk); the case that z2h(σk)¯w3 is similar. Note that, otherwise, we may choose k large enough so that z1 intersects h(σk)¯w3, and in particular, we may enforce that this intersection sΣ has length at least 2log(n). By construction and the fact that z1z2b=cz1z2, the word s must appear twice in h(σk)¯, which contradicts Proposition 28.777See in particular the proof of Proposition 28 to note that (u2,v2) can be generated by sets of the form h(σk), and by a similar argument, by those of the form h(σk)¯.

Thus, z1w1g(σk) and z2h(σk)¯w3 imply that xmw2ym is a factor of the union z2bcz1. By a counting argument, it is seen that either xmz2 or ymz1. If xmz2 – the other case is similar – then also xmz2h(σk)¯. But this is impossible by Proposition 28 and since |z2|m|x|2log(n) by (). Therefore, we have arrived at a contradiction: we can only have z1z2b=cz1z2 if b=c=ε. But now, the contrapositive of Proposition 14 shows that ym,kLq for every q(0,1/2). Since ym,k is generated by G, the result is proven. Theorem 33 and Theorem 27 combined imply our main result of this section:

Theorem 34.

For every q(0,1/2), the language Lq is not context-free.

A language L is CFL-immune if it contains no infinite context-free language as a subset. We note here that Lq cannot be CFL-immune, since for every letter xΣ, the regular language {x}+ is contained in Lq (modulo finitely many words, depending on q), and each of its words has constant complexity. However, the following holds:

Theorem 35.

For every q(0,1/2), the language ΣLq is CFL-immune.

For the proof, we direct the reader to [4]. Since ANe(x)AD(x) for all words x, Theorem 35 also implies:

Corollary 36.

For every q(0,1/2), {xΣ:AD(x)q|x|} is CFL-immune.

We conjecture that recognising Lq can be done via a linearly bounded automaton.

4 𝑳𝒒 Cannot Be Recognised by Certain Constant-Depth Circuits

In this section, we expand on our work in Section 3 by investigating the complexity of Lq further. Instead of considering pushdown automata, in this section we consider constant-depth circuits. We show that two types of circuits cannot recognise Lq either, which is analogous to Theorem 34 for pushdown automata.

Fix q(0,1/2) and fix Σ={0,1}. We first provide the definitions of two types of constant depth circuits explicitly – the class 𝐒𝐀𝐂0 in Section 4.1, and 𝐒𝐀𝐂0 in Section 4.2 – and then show that neither can recognise Lq, nor its complement.

4.1 The Circuit Class 𝐒𝐀𝐂𝟎

Suppose k1. A language L is 𝐒𝐀𝐂k-recognisable if it is recognised by a polynomial-size, O(logkn)-depth, uniform888Requiring uniformity is debatable; see e.g. [20, Remark 29]. semi-unbounded fan-in circuit (a circuit is semi-unbounded if it has unbounded fan-in-, bounded fan-in-, and admits negative literals but no other negations [3]; cf. [44, 20]). Of these classes of particular interest is 𝐒𝐀𝐂1, since it is the class 𝐥𝐨𝐠𝐂𝐅𝐋 of languages which are log-space reducible to context-free languages [43, 44]. More generally, 𝐒𝐀𝐂k enjoys the following relationship with the classical classes 𝐀𝐂k and 𝐍𝐂k:

𝐍𝐂k𝐒𝐀𝐂k𝐀𝐂k𝐍𝐂k+1 for all k1.

Just like 𝐍𝐂k and 𝐀𝐂k, the class 𝐒𝐀𝐂k is also closed under complements [3, Corollary 15].

Here, we consider the class 𝐒𝐀𝐂0. Contrary to the classes above, 𝐒𝐀𝐂0 is not closed under complementation [3]. Note that 𝐒𝐀𝐂0-circuits have constant depth; hence, the 𝐒𝐀𝐂0-recognisable languages can be characterised by formulas in a simple propositional language, as expressed in Lemma 38. We give a formal definition of 𝐒𝐀𝐂0 due to Kjos-Hanssen [20].

Definition 37.

A language L{0,1} is 𝐒𝐀𝐂0-recognisable if there exists a family (Ci)i of Boolean circuits which recognises L and which satisfies the following:

  1. 1.

    Each Ci is defined over the basic set {,} and accepts negative literals.

  2. 2.

    The family (Ci)i has constant depth.

  3. 3.

    Each Ci has unbounded fan-in- and bounded fan-in-.

  4. 4.

    Each Ci accepts words of length i.

Note that, for the classes 𝐒𝐀𝐂k with k>0, the size of the circuit must be polynomial in n. However, this requirement is redundant for 𝐒𝐀𝐂0 (cf. [20, Remark 30]). An important characterisation of 𝐒𝐀𝐂0-recognisable languages follows (cf. [20] and [3, p. 560]).

Lemma 38.

A language LΣ is 𝐒𝐀𝐂0-recognisable iff there exists c such that: for every n and every xΣn there exist kn and a Boolean formula ψn=i=1knφi,n for which φi,n is a conjunction of at most c literals, and

xLψn(x) holds.

Using this lemma, which can be deduced from the distributive properties of propositional languages, we conclude:

Theorem 39.

Let q(0,1/2) and |Σ|=2. Then Lq𝐒𝐀𝐂0 and ΣLq𝐒𝐀𝐂0.

Proof.

The proof uses a counting argument using Lemma 38. First, suppose Lq𝐒𝐀𝐂0, witnessed by a sequence of formulas (ψn)n and a constant c. Consider ψn. Since φ1,n mentions at most c variables, the circuit accepts every word which agrees on these c variables. Hence, ψn accepts at least 2nc words. Yet the order of Lq is o(2n), by Corollary 19, which contradicts the fact that (ψn)n recognises Lq.

Now, suppose ΣLq𝐒𝐀𝐂0, again accepted by (ψn)n with constant c. Separate the positive from the negative literals in φ1,n; there are at most cc such positive literals. Thus, for any word x=x1xnΣ, if xi=1 for all such positive literals, and xi=0 everywhere else, then ψn accepts x. But for large enough n, such x is in Lq by Lemma 11, which contradicts the fact that (ψn)n recognises ΣLq.

4.2 The Circuit Class 𝐒𝐀𝐂𝟎

In this section, we consider the class 𝐒𝐀𝐂0, whose definition differs from that of 𝐒𝐀𝐂0 only in the choice of base set. Let denote the 𝖷𝖮𝖱 operation. As before, fix q(0,1/2).

Definition 40.

A language L{0,1} is 𝐒𝐀𝐂0-recognisable if there exists a family (Ci)i of Boolean circuits which recognises L and which satisfies the following:

  1. 1.

    Each Ci is defined over the basic set {,} and accepts negative literals.

  2. 2.

    The family (Ci)i has constant depth.

  3. 3.

    Each Ci has unbounded fan-in- and bounded fan-in-.

  4. 4.

    Each Ci accepts words of length i.

From this definition and the following observation, we can investigate languages larger than binary. Recall that in the previous subsection, we focussed solely on the two-element alphabet {0,1}. This was forced by the fact that Boolean expressions have trouble expressing Boolean operations on non-binary languages (e.g. what does 02 evaluate to?). This can be remedied in the class 𝐒𝐀𝐂0 for some languages, courtesy of the operator .

It is readily seen that ({0,1},,) is isomorphic to the field of two elements 𝔽2=(/2,+,×). (Studying Boolean circuits in terms of the arithmetic of 𝔽2 goes back to Gál and Wigderson [8]. We also mention here similarities to the work of Razborov-Smolensky [31, 39, 38].) To extend this equivalence beyond binary alphabets, take the field 𝔽p for some prime p>2. By interpreting (,) as (+,×) mod p, we extend 𝐒𝐀𝐂0-recognisability to alphabets of prime cardinality. Below, we give a natural characterisation of 𝐒𝐀𝐂0-recognisability in terms of propositional formulas, similar to that in Lemma 38.999For a classical definition of 𝐒𝐀𝐂0 in terms of the complexity of Boolean circuits see e.g. [20, Section 4].

Definition 41.

Let |Σ|=p for some p. Then L is 𝐒𝐀𝐂0-recognisable if there exists c such that: for every n and every xΣn there exists kn and a formula ψn=i=1knφi,n for which φi,n is a conjunction of at most c literals and

xLψn(x)0.
 Remark 42.

Observe that there is a subtle difference between 𝐒𝐀𝐂0 and 𝐒𝐀𝐂0 in the case p=2. An 𝐒𝐀𝐂0 circuit accepts a word xΣn if any term in the disjunction of ψn(x) holds. On the contrary, in 𝐒𝐀𝐂0, the disjunction is interpreted as addition modulo 2, and hence, x is accepted only if the number of terms in the disjunction of ψn is odd. Also, note that Definition 41 requires a real-world formalism in which gates are able to carry out addition and multiplication modulo p as a primitive. This assumption is not needed when p=2, as such Boolean circuits can be modelled using and , as mentioned.

For completeness, we mention here that 𝐒𝐀𝐂0𝐜𝐨𝐒𝐀𝐂0 (see [3]), while 𝐜𝐨𝐒𝐀𝐂0=𝐒𝐀𝐂0 (inverting a polynomial in a finite field requires only a constant number of layers; we use this fact in the proof of Theorem 46). Further, 𝐒𝐀𝐂0𝐒𝐀𝐂0 [20, Theorem 39].

Below, we prove the following complexity characterisation of alphabets of prime cardinality.

Theorem 46.

Let |Σ|=p for some p. Then Lq𝐒𝐀𝐂0 and ΣLq𝐒𝐀𝐂0.

By translating prime-cardinality-alphabets into finite fields, we may use the tools of field theory. In this section, we collect facts about finite fields which we require to prove Theorem 46.

Lemma 43.

Let 𝔽 be a finite field.

  1. 1.

    By prime decomposition, 𝔽 has prime characteristic.

  2. 2.

    𝔽 has order pn for some p. [7, 33.2, 33.10]

  3. 3.

    If 𝔽 has order pn then 𝔽 has characteristic p. [6, Sec. 14.3]

  4. 4.

    For every p and n, there is one field up to isomorphism of order pn [7, 33.12]. This field has a subfield of order p, the prime subfield.

  5. 5.

    All functions from 𝔽 to itself are polynomial functions. [7, Exercises 22: 31.c.]

  6. 6.

    If 𝔽 has order pn and x𝔽 then xpm=xpm+n for all m. In particular, x=xpn, since the multiplicative subgroup of 𝔽 has order pn1. [6, p. 550]

If p and n, let 𝔽pn denote the (unique up to isomorphism) field of order pn.

Lemma 44.

Suppose φ:𝔽pn𝔽p is linear, i.e. φ(x+y)=φ(x)+φ(y) and φ(ax)=aφ(x) for all x,y𝔽pn and a𝔽p. Then there exist a1,,an𝔽pn for which φ(x)=i=1naixpi. In fact, every linear function from 𝔽pn to 𝔽p arises in this way.

For a proof and related details on field traces, see for instance [24, Theorem 2.24] and [24, Chapter 2.3]. In fact, their proof shows that there exists one z𝔽pn for which ai=zpi. We now give a characterisation of 𝐒𝐀𝐂0 in terms of finite fields and their operations. This characterisation is akin to that of 𝐒𝐀𝐂0 in Lemma 38 in terms of propositional formulas.

Proposition 45.

Let ϕn:𝔽pn𝔽pn be a linear isomorphism of vector spaces over 𝔽p, and suppose LΣ is 𝐒𝐀𝐂0-recognisable. Then there exists a family of polynomials (fn)n with fn:𝔽pn𝔽p for which

xLΣn(fnϕn)(x)0

and for which there exists such that for all n we have deg(fn)pnpn.

For the proof, we direct the reader to [4]. We now combine the field-theoretic tools above to prove the main theorem of this section. Recall that denotes the set of primes.

Theorem 46.

Let q(0,1/2) and |Σ|. Then Lq𝐒𝐀𝐂0 and ΣLq𝐒𝐀𝐂0.

Proof.

Suppose some circuit recognises Lq. By Proposition 45, there exists a family of polynomials (fn) and for which xLq if and only if (fnϕn)(x)0 and deg(fn)pnpn. So, the number of roots of fn – and, hence, the number of words not in Lq – is bounded above by pnpn, so the cardinality of Lq is in Ω(pn), contradicting Corollary 19.

For ΣLq, note that the circuit can be augmented by a constant number of layers to flip the output of fnϕn for any n (note that ran(fnϕn)𝔽p). If ax=(fnϕn)(x)0 then use Lemma 43 Item 6 to see that axp=ax; thus axp1=1, and so the polynomial θ(x)=1xp1 satisfies θ(x)=0ax0. As p is fixed, θ can be computed by a constant-depth circuit, which we may append to any 𝐒𝐀𝐂0-circuit recognising Lq to recognise ΣLq. Since the former does not exist, neither does the latter.

5 Open Questions

In this paper, we proved multiple results on the complexity of the measure ANe via the proxy family of sets {Lq:q(0,1/2)}. In particular, we showed that Lq is complicated from the viewpoint of pushdown automata (Theorems 34 and 35 and Corollary 36), and even certain Boolean circuits cannot recognise Lq, nor its complement (Theorems 39 and 46). We also proved the Shannon effect for ANe (Theorem 22). Pressing open questions pertain to refining these results on Lq – and, ultimately, to understanding the measure ANe even better.

In Section 4.2, and in Theorem 46 in particular, we considered alphabets of prime cardinality; however, our proof uses a non-standard definition of 𝐒𝐀𝐂0. We wonder:

Question 47.

Do the results from Theorem 46 apply to arbitrary alphabets using the definition of 𝐒𝐀𝐂0 given in Definition 40?

Finally, it is clear by definition that ANe(x)AN(x) for all xΣ, for any finite alphabet Σ. This allows the extension of certain results from ANe to AN. For instance, we note here that Theorems 33, 35, and 39 also apply to AN since ANe(x)AN(x). However, whether the equality ANe(x)=AN(x) holds in general remains the cardinal open question to fully understand the impact of exactness in Definition 7 compared to Definition 4.

Question 48.

Let Σ={0,1}. Does there exist xΣ for which ANe(x)<AN(x)?

Broadly, it is our hope that a better understanding of ANe, via proxies such as the Lq sets or otherwise, will lead to a better understanding of AN, and (non-deterministic) automatic complexity in general. Similar to the comparison between regular languages being characterised by both NFAs and DFAs, a proof of AN=ANe would simplify computing the non-deterministic automatic complexity while preserving its naturalness as a measure of complexity. Conversely, ANANe would show that non-deterministic automatic complexity is dependent on the actual computation path, which would also be of philosophical interest.

References

  • [1] Scott Aaronson. Complexity Zoo, 2025. URL: https://complexityzoo.net/Complexity_Zoo [cited 18 Apr 2025].
  • [2] Achilles A. Beros, Bjørn Kjos-Hanssen, and Daylan Kaui Yogi. Planar digraphs for automatic complexity. In Theory and applications of models of computation, volume 11436 of Lecture Notes in Comput. Sci., pages 59–73. Springer, Cham, 2019. doi:10.1007/978-3-030-14812-6_5.
  • [3] Allan Borodin, Stephen A. Cook, Patrick W. Dymond, Walter L. Ruzzo, and Martin Tompa. Two applications of inductive counting for complementation problems. SIAM J. Comput., 18(3):559–578, 1989. doi:10.1137/0218038.
  • [4] Joey Chen, Bjørn Kjos-Hanssen, Ivan Koswara, Linus Richter, and Frank Stephan. Languages of Words of Low Automatic Complexity Are Hard to Compute, 2025. arXiv:2510.07696.
  • [5] Rodney G. Downey and Denis R. Hirschfeldt. Algorithmic randomness and complexity. Theory and Applications of Computability. Springer, New York, 2010. doi:10.1007/978-0-387-68441-3.
  • [6] David S. Dummit and Richard M. Foote. Abstract algebra. John Wiley & Sons, Inc., Hoboken, NJ, third edition, 2004.
  • [7] John B Fraleigh. A first course in abstract algebra. Pearson Education, Philadelphia, PA, 7th edition, 2003.
  • [8] Anna Gál and Avi Wigderson. Boolean complexity classes vs. their arithmetic analogs. Random Struct. Algorithms, 9(1-2):99–111, 1996. doi:10.1002/(sici)1098-2418(199608/09)9:1/2<99::aid-rsa7>3.3.co;2-o.
  • [9] Seymour Ginsburg. The mathematical theory of context-free languages. McGraw-Hill Book Co., New York-London-Sydney, 1966.
  • [10] Sheila A. Greibach. A New Normal-Form Theorem for Context-Free Phrase Structure Grammars. J. ACM, 12(1):42–52, January 1965. doi:10.1145/321250.321254.
  • [11] John E Hopcroft, Rajeev Motwani, and Jeffrey D Ullman. Introduction to automata theory, languages, and computation. Pearson, Upper Saddle River, NJ, 3 edition, June 2006.
  • [12] Kayleigh Hyde. Nondeterminstic Finite State Complexity. Master’s thesis, University of Hawai’i at Mānoa, 2013. URL: http://hdl.handle.net/10125/29507.
  • [13] Kayleigh K. Hyde and Bjørn Kjos-Hanssen. Nondeterministic automatic complexity of overlap-free and almost square-free words. Electron. J. Combin., 22(3):Paper 3.22, 18, 2015. doi:10.37236/4851.
  • [14] Bakhadyr Khoussainov and Anil Nerode. Automata theory and its applications, volume 21 of Progress in Computer Science and Applied Logic. Birkhäuser Boston, Inc., Boston, MA, 2001. doi:10.1007/978-1-4612-0171-7.
  • [15] Bjørn Kjos-Hanssen. On the complexity of automatic complexity. Theory Comput. Syst., 61(4):1427–1439, 2017. doi:10.1007/s00224-017-9795-4.
  • [16] Bjørn Kjos-Hanssen. Automatic complexity of shift register sequences. Discrete Mathematics, 341(9):2409–2417, 2018. doi:10.1016/j.disc.2018.05.015.
  • [17] Bjørn Kjos-Hanssen. Automatic complexity of Fibonacci and Tribonacci words. Discrete Applied Mathematics, 289:446–454, 2021. doi:10.1016/j.dam.2020.10.014.
  • [18] Bjørn Kjos-Hanssen. An incompressibility theorem for automatic complexity. Forum Math. Sigma, 9:e62, 7, 2021. doi:10.1017/fms.2021.58.
  • [19] Bjørn Kjos-Hanssen. Automatic complexity—a computable measure of irregularity, volume 12 of De Gruyter Series in Logic and its Applications. De Gruyter, Berlin, [2024] ©2024. doi:10.1515/9783110774870.
  • [20] Bjørn Kjos-Hanssen. Maximal automatic complexity and context-free languages. In Aspects of computation and automata theory with applications, volume 42 of Lect. Notes Ser. Inst. Math. Sci. Natl. Univ. Singap., pages 335–352. World Sci. Publ., Hackensack, NJ, [2024] ©2024. doi:10.1142/9789811278631_0013.
  • [21] A. N. Kolmogorov. Three approaches to the definition of the concept “quantity of information”. Problemy Peredači Informacii, 1(vyp. 1):3–11, 1965. URL: https://www.mathnet.ru/eng/ppi68.
  • [22] L. A. Levin. Laws of Information Conservation (Nongrowth) and Aspects of the Foundation of Probability Theory. Problems Inform. Transmission, 10(3):206–210, 1974. URL: https://www.mathnet.ru/eng/ppi1039.
  • [23] Leonid A. Levin. Some theorems on the algorithmic approach to probability theory and information theory: (1971 dissertation directed by a.n. kolmogorov). Annals of Pure and Applied Logic, 162(3):224–235, 2010. Special Issue: Dedicated to Nikolai Alexandrovich Shanin on the occasion of his 90th birthday. doi:10.1016/j.apal.2010.09.007.
  • [24] Rudolf Lidl and Harald Niederreiter. Finite fields, volume 20 of Encyclopedia of Mathematics and its Applications. Cambridge University Press, Cambridge, second edition, 1997. With a foreword by P. M. Cohn. doi:10.1017/CBO9780511525926.
  • [25] O. B. Lupanov. The synthesis of contact circuits. Dokl. Akad. Nauk SSSR (N.S.), 119:23–26, 1958.
  • [26] O. B. Lupanov. The schemes of functional elements with delays. Problemy Kibernet., (23):43–81, 303, 1970.
  • [27] R. C. Lyndon and M. P. Schützenberger. The equation aM=bNcP in a free group. Michigan Math. J., 9:289–298, 1962. URL: http://projecteuclid.org/euclid.mmj/1028998766.
  • [28] Per Martin-Löf. The definition of random sequences. Information and Control, 9:602–619, 1966. doi:10.1016/S0019-9958(66)80018-9.
  • [29] Jaban Meher and M. Ram Murty. Ramanujan’s proof of Bertrand’s postulate. Amer. Math. Monthly, 120(7):650–653, 2013. doi:10.4169/amer.math.monthly.120.07.650.
  • [30] Jakub Radoszewski, Wojciech Rytter, and Tomasz Waleń. Faster Algorithms for Ranking/Unranking Bordered and Unbordered Words. In Zsuzsanna Lipták, Edleno Moura, Karina Figueroa, and Ricardo Baeza-Yates, editors, String Processing and Information Retrieval, pages 257–271, Cham, 2025. Springer Nature Switzerland. doi:10.1007/978-3-031-72200-4_20.
  • [31] A. A. Razborov. Lower bounds on the size of bounded depth circuits over a complete basis with logical addition. Mathematical notes of the Academy of Sciences of the USSR, 41(4):333–338, April 1987. doi:10.1007/BF01137685.
  • [32] Maria José Serna. Asymptotical behaviour of some non-uniform measures. RAIRO - Theoretical Informatics and Applications - Informatique Théorique et Applications, 23(3):281–293, 1989. doi:10.1051/ita/1989230302811.
  • [33] Jeffrey Shallit. A Second Course in Formal Languages and Automata Theory. Cambridge University Press, USA, first edition, 2008. doi:10.1017/CBO9780511808876.
  • [34] Jeffrey Shallit and Yuri Breitbart. Automaticity I: Properties of a Measure of Descriptional Complexity. Journal of Computer and System Sciences, 53(1):10–25, 1996. doi:10.1006/jcss.1996.0046.
  • [35] Jeffrey Shallit and Ming-Wei Wang. Automatic complexity of strings. J. Autom. Lang. Comb., 6(4):537–554, 2001. 2nd Workshop on Descriptional Complexity of Automata, Grammars and Related Structures (London, ON, 2000). doi:10.25596/jalc-2001-537.
  • [36] Claude. E. Shannon. The synthesis of two-terminal switching circuits. The Bell System Technical Journal, 28(1):59–98, 1949. doi:10.1002/j.1538-7305.1949.tb03624.x.
  • [37] Michael Sipser. A complexity theoretic approach to randomness. In Proceedings of the Fifteenth Annual ACM Symposium on Theory of Computing, STOC ’83, pages 330–335, New York, NY, USA, 1983. Association for Computing Machinery. doi:10.1145/800061.808762.
  • [38] R. Smolensky. Algebraic methods in the theory of lower bounds for boolean circuit complexity. In Proceedings of the Nineteenth Annual ACM Symposium on Theory of Computing, STOC ’87, pages 77–82, New York, NY, USA, 1987. Association for Computing Machinery. doi:10.1145/28395.28404.
  • [39] R. Smolensky. On representations by low-degree polynomials. In Proceedings of 1993 IEEE 34th Annual Foundations of Computer Science, pages 130–138, 1993. doi:10.1109/SFCS.1993.366874.
  • [40] Ray J Solomonoff. A preliminary report on a general theory of inductive inference, February 1960. URL: https://raysolomonoff.com/publications/z138.pdf.
  • [41] Ray J Solomonoff. A formal theory of inductive inference. Part I. Information and control, 7(1):1–22, 1964. doi:10.1016/S0019-9958(64)90223-2.
  • [42] Ray J Solomonoff. A formal theory of inductive inference. Part II. Information and control, 7(2):224–254, 1964. doi:10.1016/S0019-9958(64)90131-7.
  • [43] I. H. Sudborough. On the tape complexity of deterministic context-free languages. J. Assoc. Comput. Mach., 25(3):405–414, 1978. doi:10.1145/322077.322083.
  • [44] H. Venkateswaran. Properties that characterize LOGCFL. J. Comput. System Sci., 43(2):380–404, 1991. doi:10.1016/0022-0000(91)90020-6.
  • [45] I. Wegener. The Complexity of Boolean Functions. Wiley Teubner on Applicable Theory in Computer Science. Wiley, 1987.