aa r X i v : . [ c s . CC ] S e p Pebble-Depth
Liam Jordon ∗ [email protected] Philippe [email protected]. of Computer Science, Maynooth University, Maynooth, Co.Kildare, Ireland. Abstract
In this paper we introduce a new formulation of Bennett’s logical depthbased on pebble transducers. This notion is defined based on the differencebetween the minimal length descriptional complexity of strings from theperspective of finite-state transducers and pebble transducers. Our notionof pebble-depth satisfies the three fundamental properties of depth: i.e.easy sequences and random sequences are not deep, and the existence ofa slow growth law. We also compare pebble-depth to other depth notionsbased on finite-state transducers, pushdown compressors and the Lempel-Ziv 78 compression algorithm. We first demonstrate how there exists anormal pebble-deep sequence even though there is no normal finite-state-deep sequence. We next build a sequence which has a pebble-depth level ofroughly 1, a pushdown-depth level of roughly 1 / / Keywords:
Logical Depth, Pebble Transducer, Finite-State Transducers,Pushdown Compressors, Lempel-Ziv Algorithm, Kolmogorov Complexity
In 1988 Charles Bennett introduced a new method to measure the usefulness ofa piece of data [3]. He called this tool logical depth . Intuitively deep structurescan be thought of as structures which contain complex patterns that are hardto find. Given more time and resources, an algorithm could identify patternsin the structure to exploit them. Non-deep structures are referred to as being shallow . Random structures are considered shallow as they contain no patternsto identify. Simple structures are considered shallow as while they containpatterns, they are too easy to spot.While Bennett’s original notion was based on uncomputable Kolmogorovcomplexity and interacts nicely with several aspects of computability theory ∗ Supported by a postgraduate scholarship from the Irish Research Council. polyregular func-tions. While there are several equivalent characterisations of polyregular func-tions [4, 5], we examine the characterisation given by a restricted class of pebble transducers. For k ∈ N , a k -pebble transducer is a two-way finite-state trans-ducer with the additional capacity to mark k squares of its tape with its pebbles .The restriction we place on the pebble transducers we examine are ones whichfollow a stack-like discipline in the sense that the pebbles are ordered and apebble’s position on the tape can only be altered (lifted from, dropped onto ormoved to a different square) if all lower ranked pebbles are currently on the tapeand all higher ranked pebbles are not currently on the tape. This restricted classof pebble machines was examined as acceptors by Globerman and Harel whoshowed they recognise the regular languages [15]. They were first examined astransducers for tress by Milo et al. in [22]. Further study of pebble-transducersfor strings by Engelfriet and Maneth can be found in [13]. While equivalentto two-way finite-state acceptors, pebble transducers are much more powerful.Specifically, a recent result by Lhote demonstrates that a polyregular functionhas output of size O ( n k +1 ) in relation to an input of length n if and only if thefunction can be performed by a k -pebble transducer [20].Depth notions are defined via two families of observers (e.g. lossless compres-sors) T and T ′ (where T ′ is more powerful than T ) which operate on strings.We say a sequence S is ( T, T ′ )-deep if for every observer G of type T , thereexists an observer G ′ of type T ′ such that on almost every prefix of S , G ′ per-forms better than G on the prefix by at least αn bits where α ∈ (0 ,
1) and n is the length of the prefix. We refer to α as the ( T, T ′ )-depth level of S .Bennett’s original notion was based on time bounded Kolmogorov complexity K t and ordinary Kolmogorov complexity K , i.e. ( K t , K )-depth. Inspired bythis, we define pebble-depth (PB-depth) to be based on the difference betweenthe minimal descriptional complexity of strings when restricted to finite-statetransducers and pebble transducers, i.e. (FST , PB)-depth. We propose thatfinite-state transducers are a good candidate for the weaker classes of observersas finite-state transducers can be viewed as 0-pebble transducers with the addedrestriction that the tape can only move in one direction. We prove our newpebble notion satisfies the three basic properties of depth that are generallyconsidered fundamental, i.e. random sequences are shallow (for the appropri-ate randomness notion), computable sequences are shallow (for the appropriaterandomness notion), and that a slow growth law is satisfied (deep sequencescannot be computed quickly from shallow sequences).2e compare PB-depth with i.o. finite-state-depth (FS-depth) which is basedon finite-state-transducers [9], pushdown-depth (PD-depth) which is based onlossless pushdown compressors whose stack is bounded by height O (log n ) oninputs of length n [17], and Lempel-Ziv-depth (LZ-depth) [17] based on thelossless compression algorithm Lempel-Ziv 78 [29]. To compare PB-depth withFS-depth and PD-depth, we build a sequence S that has a PB-depth level ofapproximitately 1, PD-depth level of approximately 1 / / We write N to denote the set of all integers. All logarithms are taken in base 2.A string is an element of { , } ∗ . | x | denotes the length of string x . For n ∈ N , { , } n denotes the set of strings of length n . A sequence is an element of { , } ω .Given strings x, y and a sequence S , xy and xS denote the concatenation of x with y and x with S respectively. For a string x and n ∈ N , x n denotes thestring of n copies of x concatenated together. For a string x and sequence S ,for positive integers i, j with i ≤ j , x [ i..j ] and S [ i..j ] represent the substring of x and S composed of their respective ( i + 1) th through ( j + 1) th bits. If j < i , then x [ i..j ] = S [ i..j ] = λ , where λ is the empty string. x [ i ] and S [ i ]represent the i th bit of x and S respectively. For a string v = xyz we say x is a prefix of v , y is a substring of v , and that z is a suffix of v . For a stringor sequence S and n ∈ N , S ↾ n denotes S [0 ..n − n of S . For a string x = x x . . . x n , d ( x ) denotes x with every bit doubled, i.e. d ( x ) = x x x x . . . x n x n . For a string x , x − denotes the reverse of x , i.e. x − = x n x n − . . . x x .We write K ( x ) to represent the plain Kolmogorov complexity of x . That is,for a fixed universal Turing machine U , K U ( x ) = min {| y | : y ∈ { , } ∗ , U ( y ) = x } . Here y is the shortest input to U that results in the output of x . The value K U ( x ) does not depend on the choice of universal machine up to an additiveconstant, therefore we drop the U from the notation. Other authors commonlyuse C to denote plain Kolmogorov complexity (see [26]), however we reserve C to denote compressors. Note that for all n ∈ N , there exists a string x ∈ { , } n such that K ( x ) ≥ | x | by a simple counting argument.We use Borel normality [11] to examine the properties of some sequences. Asequence S is said to be normal if for all x ∈ { , } ∗ , x occurs with asymptoticfrequency 2 −| x | as a substring in S . 3 .1 Pebble Transducers A k -pebble transducer is two-way finite-state transducer which also has k -pebbles labelled 1 , . . . , k . Initially the transducer has no pebbles on its inputtape, however during its computation the transducer can drop pebbles onto andpick up pebbles from squares on its input tape. At each stage of computationthe transducer knows which pebbles are on the square of the input tape underits head, it can choose to drop a new pebble or lift one of these pebbles. Howeverthe way in which the transducer can drop and lift pebbles is restricted to act ina stack like fashion.Formally a pebble transducer (PB) is a 6-tuple T = ( Q, q , F, k, δ, ν ) where1. Q is a non-empty, finite set of states ,2. q ∈ Q is the start state ,3. F ⊆ Q is the set of final states ,4. k is the number of pebbles allowed to be placed on the tape,5. δ : ( Q − F ) × ( { , } ∪ {⊣ , ⊢} ) × { , } k → Q × { +1 , − , push, pop } is the transition function ,6. ν : ( Q − F ) × ( { , } ∪ {⊣ , ⊢} ) × { , } k → { , } ∗ is the output function .A PB with k pebbles is referred to as a k -pebble transducer. On input x ∈ { , } ∗ , the input tape contains ⊣ x ⊢ , where ⊣ and ⊢ are the left andright end markers of the tape respectively. The tape squares are numbered0 , , . . . , | x | , | x | + 1. A configuration of T is a 4-tuple ( q, i, σ, w ) where q ∈ Q is the current state of T , 0 ≤ i ≤ | x | + 1 is the current position of the head, σ ∈ {⊥ , , . . . , | x | + 1 } k is a tuple indicating the location of the pebbles and w ∈ { , } ∗ is what T has outputted so far. That is, σ [ m −
1] = j means thatpebble m is on square j , and σ [ m −
1] = ⊥ means pebble m is not currently onthe tape. Hence by the stack nature of T , if only l pebbles are currently placedon the tape then σ [ l ] = · · · = σ [ k −
1] = ⊥ .If T is in configuration ( q, i, σ, w ) with a being the symbol on square i of thetape, then T ’s transition and output functions δ and ν take the input ( q, a, b )where for 0 ≤ j ≤ k − b [ j ] = 1 iff σ [ j ] = i . If there are l pebbles on T ’s tape, δ ( q, a, b ) = ( q ′ , d ) means that T moves from state q to state q ′ and performs d ,where +1 means move one square right, − push means place pebble l + 1 onto the current square and pop means remove pebble l from the current square. These transitions are undefined if a = ⊢ , a = ⊣ , allpebbles are currently on the tape, and pebble l is not on the current square ofthe configuration, i.e. square i . Following a transition, T enters the successor configuration ( q ′ , i ′ , σ ′ , w · ν ( q, a, b )), where q ′ , i ′ and σ ′ reflect the new state, headposition and place of the pebbles based on the result of δ ( q, a, b ). Specifically q ′ = δ Q ( q, a, b ) , i ′ ∈ { i − , i, } depending on whether the instruction was4o move left, push or pop, or move right respectively and σ ′ = σ if the instruction was +1 or − ,σ [0 ..l − i ⊥ k − l − if the instruction was to push pebble l + 1 ,σ [0 ..l − ⊥ k − l +1 if the instruction was to pop pebble l. We say that T on input x outputs w , i.e. T ( x ) = w, if starting in configuration( q , , ⊥ k , λ ), there is a finite sequence of successor configurations of T endingwith ( q, i, σ, w ), where q ∈ F . We require the use of final states to define theoutput as we do not consider cases where T finds itself in a loop and outputsan infinite sequence, i.e. T ( x ) = zy , for some z ∈ { , } ∗ and y ∈ { , } ω . Wewrite PB to denote the set of deterministic pebble transducers. We use PB k ⊂ PB to denote set of deterministic k -pebble transducers.Using constructions of [14], Engelfriet showed that deterministic PBs areclosed under composition and the composition can be realised with a minimalnumber of pebbles [12]. This property is used in the proof of a slow growth lawin theorem 3.4. Theorem 2.1 ([12]) . Let k, m ∈ N . Let K ∈ PB k and M ∈ PB m . Then thereexists some T ∈ PB km + k + m such that for all x ∈ { , } ∗ , T ( x ) = K ( M ( x )) . We use the standard finite-state transducer model.A finite-state transducer (FST) is a 4-tuple T = ( Q, q , δ, ν ), where1. Q is a nonempty, finite set of states ,2. q ∈ Q is the start state ,3. δ : Q × { , } → Q is the transition function ,4. ν : Q × { , } → { , } ∗ is the output function ,For all x ∈ { , } ∗ and b ∈ { , } , the extended transition function b δ : q × { , } ∗ → Q is defined by the recursion b δ ( λ ) = q and b δ ( xa ) = δ ( b δ ( x ) , a ) . For x ∈ { , } ∗ , the output of T on x is the string T ( x ) defined by the recursion T ( λ ) = λ , and T ( xa ) = T ( x ) ν ( b δ ( x ) , a ).An FST is information lossless (IL) if the function x ( T ( x ) , b δ ( x )) is 1-1;i.e. the output and final state of T on input x uniquely identify x . We call anFST that is IL an ILFST. By the identity FST, we mean the ILFST I FS thaton every input x ∈ { , } ∗ , I FS ( x ) = x. We write (IL)FST to denote the set ofall (IL)FSTs.A map f : { , } ω → { , } ω is said to be (IL)FS computable if there is an(IL)FST T such that for all S ∈ { , } ω , lim n →∞ | T ( S ↾ n ) | = ∞ and for all n ∈ N , T ( S ↾ n ) (cid:22) f ( S ). In this case we say T ( S ) = f ( S ).5 .3 Pushdown Compressors We use the model of pushdown compressors found in [21]. Note that we keepour model feasible by bounding the number of times a pushdown compressorcan pop a bit off of its stack without reading an input bit. This prevents thecompressor spending an arbitrarily long time altering its stack without readingits input.A pushdown compressor (PDC) is a 7-tuple C = ( Q, Γ , δ, ν, q , z , c ) where1. Q is a non-empty, finite set of states ,2. Γ = { , , z } is the finite stack alphabet ,3. δ : Q × ( { , } ∪ { λ } ) × Γ → Q × Γ ∗ is the transition function ,4. ν : Q × ( { , } ∪ { λ } ) × Γ → { , } ∗ is the output function ,5. q ∈ Q is the start state,6. z ∈ Γ is the special bottom of stack symbol,7. c is an upper bound on the number of λ -transitions per input bit.We assume every state in Q is reachable from q . We write δ Q which returnsthe first component of the output on δ and δ Γ to be the second component. Thetransition function δ accepts λ as an input in addition to { , } . This means C has the option of altering its stack while not reading an input character. Wecall this a λ -transition . In this case for a ∈ { , } , whenever δ ( q, λ, a ) = ( q ′ , λ ),we pop the top symbol from the top of the stack. To enforce determinism werequire that one of the following hold for all q ∈ Q and a ∈ Γ:1. δ ( q, λ, a ) = ⊥ δ ( q, b, a ) = ⊥ for all b ∈ { , } .For z ∈ Γ + , z is ordered such that z [0] is the top of the stack and z [ | z | −
1] = z . δ is restricted so that z cannot be popped off of the stack. That is, forevery q ∈ Q, b ∈ { , } ∪ { λ } , either δ ( q, b, z ) = ⊥ , or δ ( q, b, z ) = ( q ′ , vz )where q ′ ∈ Q and v ∈ Γ ∗ . Furthermore, at most c λ -transitions can be appliedin succession without reading an input bit.The extended transition function b δ : Q × { , } ∗ × Γ + → Q × Γ ∗ is definedby the usual recursion. b δ ( q , w, z ) is abbreviated to b δ ( w ). The extended outputfunction b ν : Q × { , } ∗ × Γ + → Q × Γ ∗ is also defined by the usual recursion.The output of the PDC C on input w ∈ { , } ∗ is the string C ( w ) = b ν ( q , w, z ) . A PDC is said to be information lossless (IL) if the map w ( C ( w ) , c δ Q ( w ))is 1-1. A PDC that is IL is called an ILPDC. We write (IL)PDC to be the setof all (IL)PDCs. Definition 2.2.
Let f be an order function. We say a PDC C has f -stackgrowth if for all x ∈ { , } ∗ , for 0 ≤ i ≤ | x | −
1, when C is reading x [ i ] as partof its computation, C ’s stack’s height is bounded above by f ( i ). We say that astack containing only z (i.e. an empty stack) has height 0.6e write (IL)PDC f to denote the set of all ILPDCs with f -stack growth.Note that I P D ∈ ILPDC f for all such f . In this paper we exclusively examineILPDCs with ⌊ log ⌋ -stack growth. The Lempel-Ziv 78 algorithm (denoted LZ) [29] is a lossless dictionary basedcompression algorithm. Given an input x ∈ { , } ∗ , LZ parses x into phrases x = x x . . . x n such that each phrase x i is unique in the parsing, except forpossibly the last phrase. Furthermore, for each phrase x i , every prefix of x i alsoappears as a phrase in the parsing. That is, if y ≺ x i , then y = x j for some j < i . Each phrase is stored in LZ’s dictionary. LZ encodes x by encoding eachphrase as a pointer to its dictionary containing the longest proper prefix of thephrase along with the final bit of the phrase. Specifically for each phrase x i , x i = x l ( i ) b i for l ( i ) < i and b i ∈ { , } . Then for x = x x . . . x n LZ ( x ) = c l (1) b c l (2) b . . . c l ( n ) b n where c i is a prefix free encoding of the pointer to the i th element of LZ’sdictionary, and x = λ . k -String Complexity In [9], a notion of finite-state-depth (FS-depth) was introduced which was basedon the finite-state complexity of strings. Further study of finite-state complexitycan be found in [6, 7]. We generalise this idea to any class of transducers T todefine our depth notions. In particular, we consider finite-state and pebble-complexity to define PB-depth. Definition 2.3.
Let F be a class of transducers. A binary representation ofF-transducers σ is a partially computable map σ : D ⊆ { , } ∗ → FST, suchthat for every transducer T ∈ F , there exists some x ∈ D such that σ ( x ) fullydescribes T , i.e. σ is surjective. If σ ( x ) = T , we call x a σ description of T .For a binary representation of F-transducers σ , we define | T | σ = min {| x | : σ ( x ) = T } to be the size of T with respect to σ . For all k ∈ N , defineF ≤ kσ = { T ∈ F : | T | σ ≤ k } to be the set of F-transducers of with σ representation size k or less. For all k ∈ N and x ∈ { , } ∗ , the k-F complexity of x with respect to binary representation σ is defined as D kσ ( x ) = min n | y | : T ∈ F ≤ kσ & T ( y ) = x o . y is the shortest string that gives x as an output when inputted into anF-transducer of size k or less with respect to the binary representation σ .We fix an arbitrary binary representation of pebble transducers in this paperand write D k PB ( x ) to represent the k -PB complexity of string x . Note that thisshould not be confused with the set PB k . We use the binary representation forFSTs presented in [16]. It is chosen as it is required in the proof of lemma 2.6which requires an upperbound for the size of FSTs with the same transition andoutput functions, but with different start states. We omit the full details of therepresentation as if a sequence is FS-deep with respect to one representation, itis FS-deep with respect to all representations [17]. Hence we write D k FS ( x ) torepresent the k -FS complexity of string x .The upper and lower randomness density of a sequence for a family of trans-ducers F are given by ρ F = lim k →∞ lim inf n →∞ D k F ( S ↾ n ) n , and R F = lim k →∞ lim sup n →∞ D k F ( S ↾ n ) n respectively. . For every sequence S , a result from [28] gives a relation between k -FS com-plexity of the prefixes of S and the compression ratio of ILFSTs on prefixes of S . Theorem 2.4 ([28]) . Let S be a sequence. Then ρ F S ( S ) = inf C ∈ ILFST lim inf n →∞ | C ( S ↾ n ) | n . Normal sequences are used in the proof of theorem 3.6. It is well knownthat a sequence is normal iff it is incompressible by information lossless finite-state transducers (see [2, 8, 27]). Combining this with theorem 2.4 gives us thefollowing corollary.
Corollary 2.5.
Let S be a sequence. Then S is normal iff ρ FS ( S ) = 1 . The binary representation of FSTs we use satisfies the following lemma. Itis used in the proof of theorem 4.4.
Lemma 2.6 ([16]) . There exists a binary representation of FSTs such that ( ∀ ∞ k ∈ N )( ∀ n ∈ N )( ∀ x, y, z ∈ { , } ∗ ) D k FS ( xy n z ) ≥ D k FS ( x )+ nD k FS ( y )+ D k FS ( z ) . In this section we present our notion of PB-depth, show it satisfies the threebasic fundamental properties of depth and identify a normal PB-deep sequence.We define PB-depth by examining the difference in k -FS and k ′ -PB complex-ity on prefixes on sequences. FSTs are chosen to compare against PBs as FSTscan be viewed as PBs with no pebbles which can only move in one direction.8 efinition 3.1. A sequence S is pebble-deep (PB-deep) if( ∃ α > ∀ k ∈ N )( ∃ k ′ ∈ N )( ∀ ∞ n ∈ N ) D k FS ( S ↾ n ) − D k ′ PB ( S ↾ n ) ≥ αn. We say PB-depth( S ) ≥ α if S is deep with depth level α. We say PB-depth( S ) < α if the previous statement does not hold.The following two lemmas demonstrate a relationships between k -FST and k -PB complexity of a string x and M ( x ), where M is an ILFST. They arerequired for the proof of the slow growth law of PB-depth in theorem 3.4. Lemma 3.2 ([9]) . Let M be an ILFST . ( ∀ k ∈ N )( ∃ k ′ ∈ N )( ∀ x ∈ { , } ∗ ) D k ′ FS ( M ( x )) ≤ D k FS ( x ) . Lemma 3.3.
Let M be an ILFST. Then ( ∀ k ∈ N )( ∃ k ′ ∈ N )( ∀ x ∈ { , } ∗ ) D k ′ PB ( x ) ≤ D k PB ( M ( x )) . Proof.
Let
M, k, x be as in the lemma. It is well known that for any M , thereexists a ILFST M − and constant b such that for all x ∈ { , } ∗ , x ↾ | x | − b ⊑ M ( M ( x )) ⊑ x Note that both M and M − an be simulated by a 0-pebbletransducer that prints nothing on first reading ⊣ , then reads its input bit bybit moving right performing the same actions as M (resp. M − ) and entersthe final state when it sees ⊢ . For simplicity we call these equivalent 0-pebbletransducers M and M − also.Let p be a k -PB minimal program for M ( x ) , i.e. A ( p ) = M ( x ) for A ∈ PB ≤ k ,and D k PB ( M ( x )) = | p | . We construct A ′ and p ′ for x . Let y = M − ( M ( x )) , i.e.there exists some z ∈ { , } ≤ b such that yz = x . Let A ′ be the PB which oninput p simulates A ( p ) to get M ( x ), and sticks the output into M − and adds z at the end of M − ’s output, i.e. when it enters the final state of M − it prints z and enters its own final state. Note that by theorem 2 . A ′ will have the samenumber of pebbles as A . Thus D | A ′ | PB ( x ) ≤ D k PB ( M ( x )). As | A ′ | depends onlyon k , the size of M and | z | ≤ b , we set k ′ to be the smallest integer that takesall the possibilities for z into account. That is D k ′ PB ( M ( x )) ≤ D k PB ( x ) . The following is a slow growth law where the easy process is considered tobe computation by an ILFST, i.e. a one way 0-pebble transducer.
Theorem 3.4 (Slow Growth Law) . Let S be a sequence. Let f : { , } ω −→{ , } ω be ILFS computable, and let S ′ = f ( S ) . If S ′ is PB-deep, then S isPB-deep.Proof. Let
S, S ′ , f be as stated, and M be an ILFST computing f . As S ′ isPB-deep,( ∃ α > ∀ k ∈ N )( ∃ k ′ ∈ N )( ∀ ∞ m ∈ N ) D k FS ( S ′ ↾ m ) − D k ′ PB ( S ′ ↾ m ) ≥ αm. For all m ∈ N , let m n be the largest integer such that M ( S ↾ m ) = M ( S ↾ m n ) = S ′ ↾ n . As M is IL, it cannot visit a state twice without outputting atleast one bit, so there exists a β > n ∈ N , n ≥ βm n .9ix l ∈ N . Let k be from Lemma 3.2 such that for all x ∈ { , } ∗ , D k FS ( M ( x )) ≤ D l FS ( x ) . As S ′ is PB-deep, there exists k ′ ∈ N such that foralmost every n D k FS ( S ′ ↾ n ) − D k ′ PB ( S ′ ↾ n ) ≥ αn. Let l ′ ∈ N be from Lemma 3.3 such that for all x ∈ { , } ∗ , D l ′ PB ( x ) ≤ D k ′ PB ( M ( x )). Hence, for almost every m , D l FS ( S ↾ m ) − D l ′ PB ( S ↾ m ) ≥ D l FS ( S ↾ m ) − D k ′ PB ( M ( S ↾ m )) ≥ D k FS ( M ( S ↾ m )) − D k ′ FS ( M ( S ↾ m ))= D k FS ( M ( S ↾ m n )) − D k ′ PB ( M ( S ↾ m n ))= D k FS ( S ′ ↾ n ) − D k ′ PB ( S ′ ↾ n ) ≥ αn ≥ αβm n ≥ αβm. Thus S is PB-deep.The following demonstrates that sequences which are easy for FSTs andrandom to PBs are shallow. Theorem 3.5.
Let S be a sequence. If ρ PB ( S ) = 1 or R FS ( S ) = 0 then S isnot PB-deep.Proof. Let S be a sequence. Suppose ρ PB ( S ) = 1. Let ε > . Then for all k andfor almost every n D k PB ( S ↾ n ) ≥ (1 − ε ) . Therefore we have for k ′ such that I FS ∈ FST ≤ k ′ D k ′ FS ( S ↾ n ) − D k PB ( S ↾ n ) ≤ n − (1 − ε ) n = εn. As ε can be chosen arbitrarily, S is not PB-deep.Suppose next that R FST ( S ) = 0 . Let ε >
0. Let k be such that for almostevery n D k FS ( S ↾ n ) ≤ εn. Then for all k ′ ∈ N , for almost every n large D k FS ( S ↾ n ) − D k ′ PB ( S ↾ n ) ≤ D k FS ( S ↾ n ) < εn. As ε was chosen arbitrarily, S is not PB-deep.The following theorem states the existence of a PB-deep sequence which isnormal. As there are no normal FS-deep sequences [9], this demonstrates adifference between the notions. It requires the following result by Lathrop andStrauss. 10 heorem 3.6 ([19]) . There exists a normal sequence S = x x x · · · such thateach x i +1 is a one bit extension of x i . Intuitively, suppose x j is the longest extension contained in a prefix of S from theorem 3.6. From a description of x j , a pebble transducer can print x x x · · · x j by continuously moving a pebble one square to the right to keeptrack of the x i ’s it has printed and move its head back and forth to print theprefixes. This results in low k -pebble complexity for S . Theorem 3.7.
There exists a normal PB-deep sequence.Proof.
Let S be the sequence from theorem 3.6. Every prefix of S can be writtenin the form x x x . . . x l x l [0 ..m −
1] for some l, m ∈ N with 0 ≤ m ≤ l .We construct the following PB T . On input of strings of the form d ( x ) b b y with b , b ∈ { , } and b = b , T outputs as follows: T uses d ( x ) and its pebblesto print every prefix of x concatenated together in order of length up until itsees 01. Upon seeing 01 T scans to the right of its input tape printing y until itreaches the end of the tape and halts. So for S ↾ n = x x x . . . x l x l [0 ..m − T ( d ( x l )01 x l [0 ..m − x x x . . . x l x l [0 ..m − n = l ( l +1)2 + m. Therefore, D | T | PB ( S ↾ n ) ≤ l + 2 + m = O ( √ n )Thus for all 0 < ε <
1, for n large, D | T | PB ( S ↾ n ) ≤ ε n. Also as S is normal it holds that ρ F S ( S ) = 1 by corollary 2.5. Thus for all k and for almost every n , D k FS ( S ↾ n ) ≥ (1 − ε n. Hence, D k FS ( S ↾ n ) − D | T | PB ( S ↾ n ) ≥ (1 − ε n − ε n = (1 − ε ) n. Thus S is PB-deep.We give a construction for T in the appendix subsection 5.1. In this section we give the definition of finite-state, pushdown and LZ-depth.We continue by comparing PB-depth with these three notions.In [9], the following definition is provided for an infinitely often FS-depthnotion. 11 efinition 4.1.
A sequence S is (infinitely often) finite-state deep (FS-deep)if ( ∃ α > ∀ k ∈ N )( ∃ k ′ ∈ N )( ∃ ∞ n ∈ N ) D k FS ( S ↾ n ) − D k ′ FS ( S ↾ n ) ≥ αn. The following notions of PD-depth and LZ-depth are presented in [17].
Definition 4.2.
A sequence S is pushdown-deep (PD-deep) if ( ∃ α > ∀ C ∈ ILPDC ⌊ log ⌋ )( ∃ C ′ ∈ ILPDC)( ∀ ∞ n ∈ N ), | C ( S ↾ n ) | − | C ′ ( S ↾ n ) | ≥ αn. Definition 4.3.
A sequence S is Lempel-Ziv deep (LZ deep) if( ∃ α > ∀ C ∈ ILFST)( ∀ ∞ n ∈ N ) , | C ( S ↾ n ) | − | LZ ( S ↾ n ) | ≥ αn. For a sequence S , FS-depth( S ), PD-depth( S ) and LZ-depth( S ) are definedsimilarly to PB-depth( S ). This subsection is devoted to building a sequence which has a PB-depth level ofroughly 1, PD-depth level of roughly 1 / R | R | F ( R − ) | R | where F is a flag and R is a string not containing F with large plain Kolmogorovcomplexity relative to its length. Note that R | R | is a string of length | R | . Froma single description of R , a pebble transducer can use a pebble to print R | R | and then its two-way tape property to print ( R − ) | R | . A large ILPDC with norestriction on its stack can be built to push R | R | onto its stack, and then whenit sees the flag F , use its stack to compress ( R − ) | R | . These R are built suchthat an ILPDC ⌊ log ⌋ is unable to push R fully onto its stack due to the stack’sheight restriction, resulting in minimal compression. For FSTs, the sequenceappears almost random and so little depth is achieved. Theorem 4.4.
For all < ε < , there exists a sequence S such that PB-depth ( S ) > − ε, PD-depth ( S ) > − ε, and FS-depth ( S ) < ε .Proof. A note on notation: In the following proof, for a PDC C and strings x and y , we occasionally use the abusive notation ¯ ν C ( y ) to represent the suffix of C ( xy )that is contributed by the y section of the input, i.e. | ¯ ν C ( y ) | = | C ( xy ) | − | C ( x ) | .We note each time it is used.Let m ∈ N to be determined later. We construct S in stages S = S S S . . . such that for all j , | S j | = 2 j , and for some i ∈ N we set S . . . S i − = 00 · · · T j which contains all strings of length j that do not contain1 m as a substring. As T j contains all strings of the form { , } m − × { } ×{ , } m − × { } · · · , we have that | T j | ≥ j (1 − m ) . For each j , let R j ∈ T mj have maximal plain Kolmogorov complexity in the sense that K ( R j ) ≥ | R j | (1 − m ) . (1)12uch an R j exists as | T j | ≥ | R j | (1 − m ) − . For all j ≥ i , we set S j = ( R | R j | j m ( R − j ) | R j | ) n j t j n j is the maximalpossible occurrences of R | R j | j m ( R − j ) | R j | zones in S j such that for t j if holdsthat m ≤ t j < | R | R j | j m ( R − j ) | R j | | + m = 2 m j + m. (2)Hence for j large, we can can bound n j from below by n j ≥ | S j | − m j − m | R j | + m > | S j | (1 − m )2 | R j | . (3)Note that i is chosen to be the least integer such that m < i .First we examine how well any ILPDC ⌊ log ⌋ compresses occurrences of R j . Let C ∈ ILPDC ⌊ log ⌋ . As C is lossless, knowing C , the state q s that C begins reading R j in, q e the state C ends up in after reading R j , the stack contents z of C as itbegins reading R j in q s , and the output b ν C ( q s , R j , z ) of C on R j , we can recover R j , i.e. there exists a machine M such that M ( C, q s , q e , z, b ν C ( q s , R j , z )) = R j . Thus if we encode a tuple ( x , x , . . . , x n ) by the string1 ⌈ log n ⌉ n x ⌈ log n ⌉ n x . . . ⌈ log n n − ⌉ n n − x n − x n , where n i = | x i | in binary, then the encoding of ( C, q s , q e , z, b ν C ( q s , R j , z )) takes | b ν C ( q s , R j , z ) | + O ( j ) + O ( | C | ) bits as | z | ≤ ⌊ log(2 j +1 − ⌋ < j + 1 . Thus wehave that | R j | (1 − m ) ≤ K ( R j ) ≤ | b ν C ( q s , R j , z ) | + O ( j ) + O ( | C | ) + O ( | M | ) . As | M | and | C | are constant we have that | b ν C ( q s , R j , z ) | > | R j | (1 − m ) − O ( j ) ≥ | R j | (1 − m ) . (4)This is similarly true for R − j blocks as K ( R j ) ≤ K ( R − j ) + O (1). Hence for j large, by (4) | C ( S . . . S j ) | − | C ( S . . . S j − ) | = | ¯ ν C ( S j ) | ≥ n j | R j | (1 − m ) . (5)Next we build an ILPDC C ′ that performs well on S j . On S . . . S i − , C ′ outputs its input, trying to find the first 1 indicating the beginning of the first R | R i | i m ( R − i ) | R i | block. On S j for j ≥ i , while on an R | R j | j block, C ′ outputs itsinput and pushes R | R j | j onto its stack. On R | R j | j , C ′ reads its input in chunks ofsize m trying to the flag 1 m . As R | R j | j is divisible by m , the first time C ′ reads1 m , it knows it has just read the flag and pops 1 m from the top of the stack. C ′ knows that the next bit it will read will be the first of ( R − j ) | R j | . From here, C ′ compares the input bit to the top of its stack making sure they match to13nsure it is reading R | R j | j reversed, popping bits as it goes. It compresses it bya ratio of v , where v ∈ N and can be made arbitrarily large when building C ′ .When its stack is empty, C ′ checks if the next m bits are 1 m . If they are, C ′ outputs its input until it sees a 0 and begins reading S j +1 . Otherwise, C ′ actsas if it were on another R | R j | j block as described above. If C ′ sees something itdoes not expect, it enters an error state and outputs its input to maintain itsIL property.Hence for j large | ¯ ν C ′ ( S j ) | = | C ′ ( S . . . S j ) | − | C ′ ( S . . . S j − ) | ≤ n j ( | R j | (1 + 1 v ) + m ) + t j + 1 < n j ( | R j | (1 + 1 v ) + m ) + 2 | R j | + 2 m< n j ( | R j | (1 + 1 v ) + m ) + 2( | R j | (1 + 1 v ) + m )= ( n j + 2)( | R j | (1 + 1 v ) + m ) ≤ n j | R j | (1 + 2 v ) . (6)Therefore, choosing m and v such that m + v < − m , for j large with m + v < ε < − m we have that | ¯ ν C ( S j ) | − | ¯ ν C ′ ( S j ) | ≥ n j (2 | R j | (1 − m ) − | R j | (1 + 2 v )) (by (5) & (6))= n j | R j | (1 − m − v ) > n j ( | R j | (1 − ε )) (7) > | S j | (1 − m )2 | R j | ) | R j | (1 − ε ) (by (3)) > | S j | − ε ) . ( m + ε < ε < )Say | ¯ ν C ( S j ) | − | ¯ ν C ′ ( S j ) | > | S j | − ε )holds for all j ≥ ˆ j . Then for j large | C ( S . . . S j ) | − | C ′ ( S . . . S j ) | ≥ | S ˆ j . . . S j | ( 1 − ε − | S . . . S ˆ j − |≥ | S . . . S j | ( 12 − ε ) . (8)Next we examine an arbitrary prefix S ↾ n of S . Let j and 0 < s ≤ n j be maximum such that S . . . S j − ( R | R j | j m ( R − j ) | R j | ) s is a prefix of S ↾ n. Let14 ∈ { , } ∗ be such that S . . . S j − ( R | R j | j m ( R − j ) | R j | ) s y = S ↾ n . Note that | y | ≤ m j + m. Then for | ¯ ν C ′ ( y ) | = | C ( S . . . ( R | R j | j m ( R − j ) | R j | ) s y ) | − | C ( S . . . ( R | R j | j m ( R − j ) | R j | ) s ) | , we have that | C ( S ↾ n ) | − | C ′ ( S ↾ n ) | ≥ | S . . . S j − | ( 12 − ε )+ s | R j | (1 − ε ) − | ¯ ν C ′ ( y ) | (by (7) & (8)) ≥ | S . . . S j − | ( 12 − ε )+ s | R | R j | j m ( R − j ) | R j | | − m )(1 − ε ) − | y |≥ | S . . . S j − | ( 12 − ε ) + s (2 | R j | + m )( 12 − ε ) − | y | = ( n − | y | )( 12 − ε ) ≥ n ( 12 − ε ) . (for ε < ε < as n = O (2 j ))That is, PD ⌊ log ⌋ -depth( S ) ≥ − ε .Next we examine the FS-depth of S . For a prefix S ↾ n of S , let j and s ≤ n j be maximal such that S . . . S j − ( R | R j | j m ( R − j ) | R − j | ) s y = S ↾ n. Note | y | ≤ m j + m . For all k and j , | R j | (1 − m ) ≤ K ( R j ) ≤ D k FS ( R j ) + O (1) . So for j large, (say j ≥ j ′ ), D k FS ( R j ) > | R j | (1 − m ) . (9)This is similarly true for R − j blocks as K ( R j ) ≤ K ( R − j ) + O (1).By Lemma 2.6, we can bound the k -FS complexity of S ↾ n below by thesum of the 3 k -FS complexity of all the R | R j | j and ( R − j ) | R j | blocks. So, for j large such that j ≥ j ′ k FS ( S ↾ n ) ≥ (2 j − X a = j ′ n a | R a | D k FS ( R a )) + 2 s | R j | D k FS ( R j ) + D k FS ( y ) > − m )( j − X a = j n a | R a | (1 − m ) + 2 s | R j | ) (by (9)) ≥ (1 − ε )( j − X a = j ′ | S a | + s | R | R j | j m ( R − j ) | R j | | ) (as m < ε < ε )= ( n − | y | − | S . . . S j ′ − | )(1 − ε ) > n (1 − ε ) . (10)So for some k ′ where I FS ∈ FST ≤ k ′ , for almost every nD k ′ FS ( S ↾ n ) − D k FS ( S ↾ n ) < n − n (1 − ε ) = nε . That is, FS-depth( S ) < ε .Next we examine PB-depth. Consider the pebble-transducer T that readsits input the following way: T reads its input in chunks of size 2. If T reads achunk 10 in its input, T then scans to find the next chunk of unequal bits (orthe end of the tape), and prints the square of the strings between the chunks(or the end of the tape), followed by 1 m , followed by the square of the reversebetween the chunks using its pebbles. That is, if T reads an input with thesubstring 10 d ( x ) b b , with b = b , x ∈ { , } ∗ , then T outputs x | x | m ( x − ) | x | on that string. If T reads the chunk 01, then T reads its input in chunks of size2, outputting the bit from each chunk if the bits match until it sees an unequalchunk or it reaches the end of the tape. That is, if T reads an input with thesubstring 01 d ( x ) b b , with b = b , x ∈ { , } ∗ , or the tape ends with 01 d ( x ) ⊢ ,then T outputs x . T enters its final state upon seeing ⊢ if the last flag it sawwas 01, i.e. T must ’print’ at least the empty string to enter a final stateTherefore we have that T ((10 d ( R j )) n j d (1 t j S j . So for all 0 < β < β < /
2, for j large (say j ≥ j ∗ ) it holds that D | T | PB ( S j ) ≤ n j (2 | R j | + 2) + 2 + 2( t j + 1) < n j (2 | R j | + 2) + 2 + 2(2 | R j | + 2 m + 1) (by (2))= n j (2 | R j | + 2) + 2( | R j | + m ) + O (1) ≤ n j β (2 | R j | + m ) + 2(2 | R j | + m ) (11)= ( n j β + 2)(2 | R j | + m ) < β n j (2 | R j | + m ) < β | S j | . (12)16ext we examine the | T | -pebble complexity for an arbitrary prefix of S. Eachprefix S ↾ n can be written int the form S . . . S j − ( R | R j | j m ( R − j ) | R j | ) s y , for j, s maximal and the appropriate y . Therefore we have that S ↾ n = T (10 d ( S . . . S j ∗ − ) X j ∗ . . . X j − (10 d ( R j )) s d ( y )) , where X i = (10 d ( R i )) n i d (1 t i | X i | < β | S i | by (12) for all i ≥ j ∗ . Thus for β < β < , for long enough prefixes we have D | T | PB ( S ↾ n ) ≤ (2 + 2 | S . . . S j ∗ − | ) + β | S j ∗ . . . S j − | + β ( s | R | R j | j m ( R − j ) | R j | | ) + 2 + 2 | y | (by (12)) ≤ β ( | S . . . S j − | ) + β ( s | R | R j | j m ( R − j ) | R j | | ) + 2 + 2 | y | . (13)As β can be chosen arbitrarily such that ε + β < we have that for all k , itfollows from equations (10) and (13) that for ε + β < β < and n large that D k FS ( S ↾ n ) − D | T | PB ( S ↾ n ) ≥ n (1 − ε ) − β ( | S . . . S j − | ) − β ( s | R | R j | j m ( R − j ) | R j | | ) − − | y |≥ n (1 − ε ) − n ( β ) − O ( j ) (as | y | = O ( j )) ≥ n (1 − β ) . Thus we have that PB-depth( S ) ≥ − β . And as ε < β we also have thatPD ⌊ log ⌋ -depth( S ) ≥ − β and FS-depth( S ) < β . Choosing m, v and β appropriately allows us to attain the desired depth value. For completeness, theconstruction of T is confined to the appendix subsection 5.2. The following demonstrates the existence of a sequence S with PB-depth ofroughly and low LZ-depth. The sequence is that from Theorem 4.12 of [21].This sequence is broken into blocks where each block is a concatenation of almostevery string of length n . Specifically blocks are composed of subblocks of theform XF Y where X is a listing of a selection of strings of length n , F is a flagnot contained in any string of length n listed, and Y is a listing of strings oflength n such that Y = X − . A pebble transducer can perform well on thissequence as given X , the transducer can use its two-way tape property to print Y also. LZ does not perform well on S as it is almost a listing of every stringin order of length. LZ performs poorly on such sequences. Theorem 4.5.
For each < ε < , there exists a sequence S such that PB-depth ( S ) ≥ − ε and LZ-depth ( S ) < ε. roof. Let S be a sequence that satisfies Theorem 4.12 of [21]. We give a recapof the construction of S here.Let 0 < ε <
1, and let k = k ( ε ) > v = v ( ε ) be integers to bedetermined later. For any n ∈ N , let T n denote the set of strings of length n that do not contain the substring 1 j in x for all j ≥ k . As T n contains the setof strings whose every k th bit is 0, it follows that | T n | ≥ ( k − k ) n . Note that forevery x ∈ T n , there exists y ∈ T n − , b ∈ { , } such that x = yb .Let A n = { a n , . . . , a u n } be the set of palindromes in T n . As fixing thefirst n bits determines a palindrome (wlog n even), | A n | ≤ n . The remainingstrings in T n − A n are split into v pairs of sets X n,i = { x n,i, , . . . , x n,t n , } and Y n,i = { y n,i, , . . . , y n,t n , } with t n = | T n − A n | v , ( x n,i,j ) − = y n,i,j for every1 ≤ j ≤ t n and 1 ≤ i ≤ v , x n,i, , y n,i,t n start with 0. For convenience we write X i , Y i for X n,i , Y n,i respectively. S is constructed in stages. Let f ( k ) = 2 k and f ( n + 1) = f ( n ) + v + 1. Notethat n < f ( n ) < n . For n ≤ k − S is a concatenation of all strings of length n , i.e. S n = 0 n · n − · · · n − · n . For n ≥ k , S n = a n . . . a u n f ( n ) z n, z n, . . . z n,v where z n,i = x n,i, x n,i, . . . x n,i,t n − x n,i,t n f ( n )+ i y n,i,t n y n,i,t n − . . . y n,i, y n,i, . That is, S n is a concatenation of all strings in A n followed by a flag of f ( n ) ones,follows by concatenation of all strings in the X i zones and Y i zones separatedby flags of increasing length such that each Y i zone is the X i zone written inreverse. Let S = S S . . . S k − k k +1 . . . k − S k S k +1 . . . i.e. the concatenation of all S j zones with some extra flags between S k − and S k . We build T the 1-pebble transducer that acts as follows. T begins movingright and printing its input until it sees the first 0 after a flag of 2 k ones. Uponseeing this 0, if the succeeding bit is a 1, T stays in the print zone. T movesright and prints what is on its tape until it sees a flag of 2 k ones followed by a0 again. If T sees a 0 after 1 k T enters a print-and-reverse zone. T drops itspebble on the succeeding square. T moves its head right printing what it seesuntil it sees 1 k T prints what it sees (i.e. printing the reverse ofwhat it just printed) until it reaches the square with the pebble, printing whatis on it. T then moves right until it sees 1 k y = S . . . S k − k . . . k − . Then T ( y
0) = y. Note that | y | + 1 < k . For n ≥ k and 1 ≤ i ≤ v , let σ n,i = 0 x n,i,t n f ( n )+ i , and π n = 1 a n . . . a u n f ( n ) , and τ n = π n σ n, σ n, . . . σ n,v . Note that | τ n | ≤ | A n | n + ( v + 1)( f ( n ) + v ) + 2( v + 1) + n | T n − A n | = | A n | n + ( v + 1)( f ( n ) + v + 2) + n | T n − A n | . Then as T ( y τ k . . . τ n − ) = S . . . S k − k . . . k − S k . . . S n − , it follows that D | T | PB ( S . . . S k − k . . . k − S k . . . S n − ) ≤ | S . . . S k − k . . . k − | + 1+ n − X j = k [ | A j | j + ( v + 1)( f ( j ) + v + 2) + j | T j − A j | ] . Let w p be the string such that T ( w p ) = S ↾ p. Note that the ratio | w p || p | ismaximal if the suffix of S ↾ p is a full concatenation of a Y n,i zone without thefinal bit. That is, S ↾ p ends with a suffix of the form y n,i,t n . . . y n,i, y n,i, [0 ..n − . Let 0 ≤ I < v . We examine the ratio | w p || S ↾ p | inside zone S n on the second lastsymbol of the Y I +1 zone. Note that T outputs S ↾ p on input y τ k . . . τ n − π n σ n, . . . σ n,I z where z = x n,I +1 , . . . x n,I +1 ,t n f ( n )+ I +1 y n,I +1 ,t n . . . y n,I +1 , y n,I +1 , [0 ..n − . Thus | w p | ≤ k + n − X j = k [ | A j | j + ( v + 1)( f ( j ) + v + 2) + j | T j − A j | ]+ | A n | n + ( v + 1)( f ( n ) + v + 2) + I ( n | T n − A n | v ) + n | T n − A n | v ≤ cn + n − X j = k j | T j | + n | T n | v ( I cn + n − X j = k j | T j | + n | T n | v ( I + 2) , c > / / n large.The number of bits in such a prefix of S is | S ↾ p | ≥ n − X j = k j | T j | + n | A n | + nv | T n − A n | ( I + 1)= n − X j = k j | T j | + nv | T n | ( I + 1) + n | A n | (1 − ( I + 1) v ) ≥ n − X j = k j | T j | + nv | T n | ( I + 1) . Hence lim sup n →∞ | w n || S ↾ n | ≤ lim sup n →∞ cn + P n − j = k j | T j | + n | T n | v ( I + 2) P n − j = k j | T j | + n | T n | v ( I + 1)= lim sup n →∞ (cid:20) cn P n − j = k j | T j | + n | T n | v ( I + 1)+ 12 P n − j = k j | T j | + n | T n | v ( I + 1) P n − j = k j | T j | + n | T n | v ( I + 1)+ n | T n | v P n − j = k j | T j | + n | T n | v ( I + 1) (cid:21) = lim sup n →∞ (cid:20) cn P n − j = k j | T j | + n | T n | v ( I + 1) + 12+ n | T n | v P n − j = k j | T j | + n | T n | v ( I + 1) (cid:21) . As P n − j = k j | T j | ≥ ( n − | T n − | ≥ ( n − | T n | , we have n − X j = k j | T j | + nv | T n | ( I + 1) ≥ n − | T n | + nv | T n | ( I + 1)= n | T n | v (2 + 2 I + v − vn ) . Thuslim sup n →∞ cn P n − j = k j | T j | + n | T n | v ( I + 1) ≤ lim sup n →∞ cn ( n − | T n | ≤ lim sup n →∞ cn | T n |≤ lim sup n →∞ cn ( k − nk = 0 (when k > n | T n | v P n − j = k j | T j | + n | T n | v ( I + 1) ≤ n | T n | vn | T n | v (2 + 2 I + v − vn ) ≤ v (1 − n )which can be made arbitrarily small by choosing v appropriately.Therefore lim sup n →∞ | w n || S ↾ n | ≤ . From [21], let 0 < ε < be the appropriate value from choice of k and v such that lim inf n →∞ | LZ ( S ↾ m ) | m ≥ − ε . From [29], for all C ∈ ILFST it holds thatlim inf n →∞ | C ( S ↾ n ) | n ≥ lim inf n →∞ | LZ ( S ↾ n ) | n , and so ρ FS ( S ) ≥ − ε by theorem 2.4.Thus S is PB-deep as for all k , for n large D k FS ( S ↾ n ) − D | T | PB ( S ↾ n ) ≥ (1 − ε n − ( 12 + ε n = n ( 12 − ε ) . Thus PB-depth( S ) ≥ − ε. We see that LZ -depth( S ) < ε as I FS ( S ↾ n ) − | LZ ( S ↾ n ) | ≤ n − (1 − ε < εn. The construction of T is confined to the appendix subsection 5.3. Currently PB-depth is defined as a mixed notion between FSTs and PBs. Ideallya non-mixed version would be developed, i.e. a depth notion of k -PB complexityvs k ′ -PB complexity. One obstacle is finding an analogous result to Lemma 2.6which is used to prove the existence of FS-deep sequences. The current obstacleis that in the finite-case, given an FST where T ( x ) = p and T ( xy ) = pq , simplyswitching the starting state to the state which it ends reading T ( x ) in does notmean that y is a description for q since one must take into account the locationof the pebbles too after reading x . 21 eferences [1] Luis Antunes, Lance Fortnow, Dieter van Melkebeek, and N. V. Vinodchan-dran. Computational depth: Concept and applications. Theor. Comput.Sci. , 354(3):391–404, 2006. doi:10.1016/j.tcs.2005.11.033 .[2] Ver´onica Becher and Pablo Ariel Heiber. Normal numbersand finite automata.
Theor. Comput. Sci. , 477:109–116, 2013. doi:10.1016/j.tcs.2013.01.019 .[3] C. H. Bennett. Logical depth and physical complexity.
The UniversalTuring Machine, A Half-Century Survey , pages 227–257, 1988.[4] Mikolaj Bojanczyk. Polyregular functions.
CoRR , abs/1810.08760, 2018.URL: http://arxiv.org/abs/1810.08760 , arXiv:1810.08760 .[5] Mikolaj Bojanczyk, Sandra Kiefer, and Nathan Lhote. String-to-string interpretations with polynomial-size output. In , volume 132 of LIPIcs , pages106:1–106:14. Schloss Dagstuhl - Leibniz-Zentrum f¨ur Informatik, 2019. doi:10.4230/LIPIcs.ICALP.2019.106 .[6] Cristian S. Calude, Kai Salomaa, and Tania Roblot. Finitestate complexity.
Theor. Comput. Sci. , 412(41):5668–5677, 2011. doi:10.1016/j.tcs.2011.06.021 .[7] Cristian S. Calude, Ludwig Staiger, and Frank Stephan. Finitestate incompressible infinite sequences.
Inf. Comput. , 247:23–36, 2016. doi:10.1016/j.ic.2015.11.003 .[8] Jack Jie Dai, James I. Lathrop, Jack H. Lutz, and Elvira Mayor-domo. Finite-state dimension.
Theor. Comput. Sci. , 310(1-3):1–33, 2004. doi:10.1016/S0304-3975(03)00244-5 .[9] David Doty and Philippe Moser. Feasible depth. In
Computation andLogic in the Real World, Third Conference on Computability in Europe,CiE 2007, Siena, Italy, June 18-23, 2007, Proceedings , volume 4497of
Lecture Notes in Computer Science , pages 228–237. Springer, 2007. doi:10.1007/978-3-540-73001-9\_24 .[10] Rod Downey, Michael McInerney, and Keng Meng Ng. Low-ness and logical depth.
Theor. Comput. Sci. , 702:23–33, 2017. doi:10.1016/j.tcs.2017.08.010 .[11] M. ´Emile Borel. Les probabilits dnombrables et leurs applications arithm-tiques.
Rendiconti del Circolo Matematico di Palermo , 27(1):247–271, 1909. doi:10.1007/BF03019651 . 2212] Joost Engelfriet. Two-way pebble transducers for partial functionsand their composition.
Acta Informatica , 52(7-8):559–571, 2015. doi:10.1007/s00236-015-0224-3 .[13] Joost Engelfriet and Sebastian Maneth. Two-way finite state trans-ducers with nested pebbles. In
Mathematical Foundations of Com-puter Science 2002, 27th International Symposium, MFCS 2002, War-saw, Poland, August 26-30, 2002, Proceedings , volume 2420 of
Lec-ture Notes in Computer Science , pages 234–244. Springer, 2002. doi:10.1007/3-540-45687-2\_19 .[14] Viliam Geffert and Lubom´ıra Istonov´a. Translation from classical two-wayautomata to pebble two-way automata.
RAIRO Theor. Informatics Appl. ,44(4):507–523, 2010. doi:10.1051/ita/2011001 .[15] Noa Globerman and David Harel. Complexity results for two-way andmulti-pebble automata and their logics.
Theor. Comput. Sci. , 169(2):161–184, 1996. doi:10.1016/S0304-3975(96)00119-3 .[16] Liam Jordon and Philippe Moser. On the difference between finite-state and pushdown depth. In , volume 12011 of
Lecture Notes in Computer Science , pages 187–198. Springer, 2020. doi:10.1007/978-3-030-38919-2\_16 .[17] Liam Jordon and Philippe Moser. Pushdown and lempel-ziv depth, 2020.(preprint). arXiv:2009.04821 .[18] James I. Lathrop and Jack H. Lutz. Recursive computational depth.
Inf.Comput. , 153(1):139–172, 1999. doi:10.1006/inco.1999.2794 .[19] James I. Lathrop and Martin Strauss. A universal upper bound on theperformance of the lempel-ziv algorithm on maliciously-constructed data.In
Compression and Complexity of SEQUENCES 1997, Positano, Amalfi-tan Coast, Salerno, Italy, June 11-13, 1997, Proceedings , pages 123–135.IEEE, 1997. doi:10.1109/SEQUEN.1997.666909 .[20] Nathan Lhote. Pebble minimization of polyregular functions. In
LICS’20: 35th Annual ACM/IEEE Symposium on Logic in Computer Sci-ence, Saarbr¨ucken, Germany, July 8-11, 2020 , pages 703–712. ACM, 2020. doi:10.1145/3373718.3394804 .[21] Elvira Mayordomo, Philippe Moser, and Sylvain Perifel. Polylog space com-pression, pushdown compression, and lempel-ziv are incomparable.
TheoryComput. Syst. , 48(4):731–766, 2011. doi:10.1007/s00224-010-9267-6 .[22] Tova Milo, Dan Suciu, and Victor Vianu. Typechecking forXML transformers.
J. Comput. Syst. Sci. , 66(1):66–97, 2003. doi:10.1016/S0022-0000(02)00030-2 .2323] Philippe Moser. On the polynomial depth of various setsof random strings.
Theor. Comput. Sci. , 477:96–108, 2013. doi:10.1016/j.tcs.2012.10.045 .[24] Philippe Moser. Polylog depth, highness and lowness for E.
Inf. Comput. ,271:104483, 2020. doi:10.1016/j.ic.2019.104483 .[25] Philippe Moser and Frank Stephan. Depth, highness and DNRdegrees.
Discret. Math. Theor. Comput. Sci. , 19(4), 2017. doi:10.23638/DMTCS-19-4-2 .[26] Andr´e Nies.
Computability and Randomness . Oxford University Press,2009.[27] Claus-Peter Schnorr and H. Stimm. Endliche automaten und zufallsfolgen.
Acta Informatica , 1:345–359, 1972. doi:10.1007/BF00289514 .[28] Dafna Sheinwald, Abraham Lempel, and Jacob Ziv. On encoding anddecoding with two-way head machines.
Inf. Comput. , 116(1):128–133, 1995. doi:10.1006/inco.1995.1009 .[29] Jacob Ziv and Abraham Lempel. Compression of individual sequencesvia variable-rate encoding.
IEEE Trans. Inf. Theory , 24(5):530–536, 1978. doi:10.1109/TIT.1978.1055934 .24 ppendix
For completeness, the following is a construction of T . Note that T is a 1-pebbletransducer. As such, the pebble placement part of the transition and outputfunction will have value 0 or 1 indicating whether or not the pebble is presenton the current square of the input tape.Let T = ( Q, q , F, , δ, ν ) be as follows. T has the following set of states: • q s the start state. • q p is the state T enters when it needs to move its pebble. • q b is the state which records the first bit for b ∈ { , } when examining ablock of size 2. • q l is the state used when T continuously moves its head to the left side ofthe tape. • q , q , q are the states used to print the prefixes of the input. • q i is the state where T acts as the identity transducer. • q f is the final state.Here F = { q f } . Beginning in the start state, T moves its head to the right and enters thepebble placement state, δ ( q s , ⊣ ,
0) = ( q p , +1) . Beginning in q p , T then reads the next two bits. T first records the first bitand moves right δ ( q p , b,
0) = ( q b , +1) . Then reading the second bit, if it matches the first bit, T places a pebble ontothe square and enters the state for scanning to the left. If they do not match, T moves right and enters the identity state. That is δ ( q b , a,
0) = ( ( q s , push ) if a = b, ( q i , +1) if a = b. In q l , T scans left to the end of the tape. That is, for b, c ∈ { , } , δ ( q l , b, c ) = ( q l , − . When T reaches the end of the tape, it begins reading in chunks of size two,printing every second bit, until it sees the square containing the pebble. T firstmoves its head right, δ ( q l , ⊣ ,
0) = ( q , +1) . then moves its head to the right to the second square on any bit, δ ( q , b,
0) = ( q , +1) . In q , if the current square contains the pebble, T pops the pebble and movesit forward two squares. If it does not, T moves right and returns to q . That is,on any bit b , δ ( q , b, c ) = ( ( q , +1) if c = 0 , ( q , pop ) if c = 1 . In q , T returns to q p and moves its head to the right to begin the processof moving the pebble again. That is, δ ( q , b,
0) = ( q p , +1) . When in state q i , T moves right regardless of the bit read. That is, δ ( q i , b,
0) = ( q i , +1) .T enters its final state if T reaches the right hand side of the tape in states q p , q b or q i . That is, for q ∈ { q p , q b , q i } , δ ( q, ⊢ ,
0) = ( q f , − .T outputs the empty string on all transitions except in the following caseswhere it prints the bit on the current square, ν ( q , b, c ) = b, (for c ∈ { , } ) ν ( q i , b,
0) = b. This completes the construction of T . The following is the construction of T for completeness: The transitions of T are composed of three zones: print , print-square and print-reverse-square . T ’sstate are split into four subsets P (the sets used in the zone ), R (the sets usedin the print-square zone), L (the sets used in the print-reverse-square zone) and Q (the remaining states including the flag finding, dead, and final states).We let T = { Q ∪ P ∪ R ∪ L, q s , { q f } , , δ, ν ) be a 1-pebble transducer. Thestates of T are as follows:1. Q = { q s , q − , q , q , q , q d , q ′ d , q f } (a) q s is the start state,(b) q − , q , q b for b ∈ { , } are to states used to identify flags,26c) q d , q ′ d the dead states,(d) q f the final state,2. P = { p , p , p } R = { r • , r • , , r • , , r s , r s , r l , r l, , r l, , r − p , r p , r p, , r p, , r f , r ′ f } (a) r • , r • ,b for b ∈ { , } are used to place the pebble on the tape whilelooking for a flag,(b) r s , r s , r l , r l,b for b ∈ { , } are used to scan to the left to find a flag,(c) r − p , r p , r p,b for b ∈ { , } are used to print the input read,(d) r f , r ′ f are used to find and pop the pebble on the tape,4. L = { l i , l • , l • , , l • , , l s , l s , l r , l r, , l r, , l − p , l p, , l p, , l p , l f , l ′ f } (a) l i the initial state of the print-reverse-square zone,(b) l • , l • ,b for b ∈ { , } are used to place the pebble on the tape whilelooking for a flag,(c) l s , l s , l r , l r,b for b ∈ { , } are used to scan right to find a flag,(d) l − p , l p,b , , l p for b ∈ { , } are used to the reverse of the input read,(e) l f , l ′ f are used to find and pop the pebble off of the tape.From the start state q s , T checks whether the next two squares contain 01or 10 to indicate whether it is entering a print or print-square zone respectively. T first moves right off of ⊣ . δ ( q s , ⊣ ,
0) = ( q , +1) . In q , T reads what is under its head and moves right to check the next bit.That is δ ( q , b,
0) = ( ( q d , −
1) if b = ⊢ ,( q b , +1) otherwise.For b ∈ { , } , in q b checks whether it sees a 10 flag or a 01 flag. If the bitsare the same, T repeats the process. That is δ ( q b , ˆ b,
0) = ( q d , −
1) if b = ⊢ ,( q , +1) if b = ˆ b ,( p , +1) if b ˆ b = 01,( r • , +1) if b ˆ b = 10 . First we examine the print zone. Beginning in p , T reads in chunks of sizetwo and prints the character in both cells if they contain the same bit. Thiscontinues until T sees a 10 or 01 flag or reaches the end of the tape. That is, δ ( p , b,
0) = ( ( q f , −
1) if b = ⊢ ,( p b , +1) if b ∈ { , } ,27nd, δ ( p b , ˆ b,
0) = ( p , +1) if b = ˆ b or b ˆ b = 10,( q d , −
1) if ˆ b = ⊢ ,( r • , +1) if b ˆ b = 01.We next examine print-square and print-reverse-square zones. The states r • , r • , and r • , are used to place T ’s pebble on the tape only if it sees a block oftwo of the same bits. Two non-equal bits indicates the end of the print-square portion of this zone and T enters state l i and enters the print-reverse-square zone. That is, δ ( r • , b,
0) = ( ( q d , −
1) if b = ⊢ ,( r • ,b for b ∈ { , } ,and δ ( r • ,b , ˆ b,
0) = ( q d , −
1) if b = ⊢ , ( r s , push ) if b = ˆ b ,( l i , −
1) if b = ˆ b. Once a pebble is placed on the tape and T is in r s , T must move left twoplaces and then scan left until it sees an unequal block. This is done via states r s , r s , r l, , r l, and r l . That is for b ∈ { , } , δ ( r s , b,
1) = ( r s , − ,δ ( r s , b,
0) = ( r l , − ,δ ( r l , b,
0) = ( r l,b , − δ ( r l,b , ˆ b,
0) = ( ( r l , −
1) if b = ˆ b, ( r − p , +1) if b = ˆ b . T uses states r − p , r p , r p, and r p, to read its input in blocks of two printing ifthe blocks contain the same bit until it sees a block containing unequal bits.That is, δ ( r − p , b,
0) = ( r p , +1) ,δ ( r p , b,
0) = ( ( r p,b , +1) if b ∈ { , } ,( q d , −
1) if b = ⊢ , and for c ∈ { , } , δ ( r p,b , ˆ b, c ) = ( r p , +1) if b = ˆ b ( q d , −
1) if b = ⊢ ( r f , −
1) if b = ˆ b .In states r f and r ′ f , T scans left until it finds the placed pebble to pop it.That is, δ ( r f , b,
0) = ( r f , − , δ ( r f , b,
1) = ( r ′ f , pop ) . Once popped, T moves right and enters state r • again. That is δ ( r ′ f , b,
0) = ( r • , +1) . That completes the discussion of the print-square zone. Now we discuss thestates and transitions for the print-reverse-square section of the input.Beginning in l i , T uses the states l i , l • , l • , and l • , to drop its pebble on itstape only if it sees a block of two of the same bits. Two non-equal bits indicatesthe end of the print-reverse-square portion of this zone and T enters state q − and finds the next unequal flag to indicate the beginning of the next print or print-square zone. So for b ∈ { , } δ ( l i , b,
0) = ( l • , − ,δ ( l • , b,
0) = ( l • ,b , − , and δ ( l • ,b , ˆ b,
0) = ( ( l s , push ) if b = ˆ b ,( q − , +1) if b = ˆ b .Once a pebble is placed on the tape and T is in l s , T must move left twoplaces and then scan left until it sees an unequal block. This is done via states l s , l s , r l and r l . That is for b ∈ { , } , δ ( l s , b,
1) = ( l s , +1) ,δ ( l s , b,
0) = ( l r , +1) ,δ ( l r , b,
0) = ( l r,b , +1) , and, δ ( l r,b , ˆ b,
0) = ( ( l r , +1) if b = ˆ b, ( l − p , −
1) if b = ˆ b. From l − p , T then moves left one square and then reads its tape in blocks ofsize two until it sees an unequal block, printing the bit if the bits in the blockare equal. It does this via the states l − p , l p , l p, and l p, . That is, δ ( l − p , b,
0) = ( l p , − ,δ ( l p , b,
0) = ( l p,b , − , and for c ∈ { , } δ ( l p,b , ˆ b, c ) = ( ( l p , −
1) if b = ˆ b ,( l f , +1) if b = ˆ b.
29n states l f and l ′ f , T moves right trying to find its pebble. Once found, T pops the pebble off of its tape. That is, δ ( l f , b,
0) = ( l f , +1) , and δ ( l f , b,
1) = ( l ′ f , pop ) . Once popped, T moves left and enters state l • again. That is δ ( l ′ f , b,
0) = ( l • , − . This completes the print-reverse-square zone discussion. Next we examinewhat happens when T is in state q − . T only enters this state once it hasfinished the print-reverse-square zone. Upon this, T must scan right until itfinds an unequal block of size to identify the next zone. It does this by movingright from q − and entering state q . That is, δ ( q − , b,
0) = ( q , +1) . Next we examine state q d , the dead state. T enters this state when it seesthe end of the tape when it does not expect to. From here, T remains in a loop,thus never entering a final state. That is for b, c ∈ { , } δ ( q d , b, c ) = ( q ′ d , +1) , and δ ( q ′ d , ⊢ ,
0) = ( q d , − . On every transition, T prints nothing except in the following circumstances: • ν ( p b , b,
0) = b (when in a print zone and sees an equal block) • ν ( r p,b , b,
0) = ν ( r p,b , b,
1) = b (when it is in a print-square zone and seesan equal block) • ν ( r • , , ,
0) = ν ( r • , ,
0) = 1 m (when it comes to the end of a print-square zone) • ν ( l p,b , b,
0) = ν ( l p,b , b,
1) = b (when it is in a print-reverse-square zone andsees an equal block)This completes the construction. The following is the construction of T . Let T = ( Q, q o , F, , δ, ν ) be a 1-pebbletransducer. The states of T are as follows: • q the start state, 30 q i,w for w ∈ { , } k the just printing states, • q the state used to check whether the transducer just prints or need toprint the reverse too, • q p a state used to place a the pebble, • q r,w for w ∈ { , } k , the state where T moves right printing but will printthe reverse too, • q f the state when scanning left along the flag before printing the reverse, • q l the state used to print the reverse moving left, • q s,w for w ∈ { , } k used to scan right, • q F the final state.So F = { q F } .From the start state, T moves to state q i, k and prints nothing. That is, δ ( q , ⊣ ,
0) = ( q i, k , +1) , and ν ( q , ⊣ ,
0) = λ. From here, T continuously prints what is under its head moving right untilit sees the end of a flag. At the end of the flag it moves to q . That is for w ∈ { , } k and b ∈ { , } δ ( q i,w , b,
0) = ( ( q i,w [1 .. ] b , +1) if w = 1 k or ( w = 1 k and b = 1),( q , +1) if w = 1 k and b = 0,and ν ( q i,w , b,
0) = ( b if w = 1 k or ( w = 1 k and b = 1), λ if w = 1 k and b = 0.In q , T has just read a 0 after a flag of 1 k . If T reads a 1 in q , T movesright and returns to q i, k the initial printing state. If T reads a 0, T movesright and enters the state q p and places its pebble on its tape. That is, δ ( q , b,
0) = ( ( q p , +1) if b = 0,( q i, k , +1) if b = 1. T prints nothing in q . That is, for b, c ∈ { , } ν ( q , b, c ) = λ ) . In q p , T places a pebble on its current square and enters state q r, k andprints nothing. That is, for b ∈ { , } , 31 ( q p , b,
0) = ( q r, k , push ) , and ν ( q p , b,
0) = λ.T moves its head to the right printing what it reads when in states q r,w . Itdoes this until it sees the end of a 1 k flag, upon which it moves it enters state q f moving its head to the left. That is, for b, c ∈ { , } , w ∈ { , } k , δ ( q r,w , b, c ) = ( ( q r,w [1 .. ] b , +1) if w = 1 k or ( w = 1 k and b = 1),( q f , −
1) if w = 1 k and b = 0,and ν ( q r,w , b, c ) = ( b if w = 1 k or ( w = 1 k and b = 1), λ if w = 1 k and b = 0. T moves its head to the left printing nothing while in q f until it sees a 0,that is, the end of the 1 k flag zone. When it sees a 0, T begins printing whatit reads and enters state q l . That is for b ∈ { , } , δ ( q f , b,
0) = ( ( q f , −
1) if b = 1,( q l , −
1) if b = 0,and ν ( q f , b,
0) = ( λ if b = 1,0 if b = 0.In q l , T moves its head to the left printing what it sees until it sees thesquare with the pebble. When T sees the pebble, T removes the pebble andenters state q s, k . That is for b, c ∈ { , } δ ( q l , b, c ) = ( ( q l , −
1) if c = 0,( q s, k , pop ) if c = 1,and ν ( q l , b, c ) = b.T moves its head to the right printing nothing until it sees the end of a 1 k flag, upon which it enters state q to begin the process of printing a new zoneagain. That is, for b ∈ { , } , w ∈ { , } k δ ( q s,w , b,
0) = ( ( q s,w [1 .. ] b , +1) if w = 1 k or ( w = 1 k and b = 1),( q , +1) if w = 1 k and b = 0,and ν ( q s,w , b,
0) = λ. w ∈ { , } k , if T is in state q i,w (the just printing states without revers-ing) or in state q (where T checks if the next zone is just printing or printingand reversing) and sees ⊢ indicating the right hand side of the tape, T enters q F the final state and halts, printing nothing. That is for w ∈ { , } k δ ( q i,w , ⊢ ,
0) = δ ( q , ⊢ ,
0) = ( q F , − , and ν ( q i,w , ⊢ ,
0) = ν ( q , ⊢ ,