text stringlengths 128 2.05k |
|---|
We can imagine GLCA on a fixed width space or on a cylindric grid also. We can colour and draw only the junctions instead of the arcs. It is a number triangle (from a single root pattern) or a number trapezoid (from a single row of root patterns). We have to use 8 colours to show the root patterns (junctions as data co... |
[MATH] etc. The number triangle constructed as follows: for example root patterns [MATH] are assigned with branch pattern [MATH] . As a reverse binary number it is equal to [MATH] . From root pattern [MATH] we get [MATH] , then from root pattern [MATH] we get: |
1 0 4 1 0 4 . . . 0 0 0 . . . 1 0 4 1 0 5 0 4 We can make the 2D version of GLCA represented by arcs in 3D cubic space. Consider y axis as the growing direction otherwise the time. We get 9 possible arcs (1 vertical, 4 diagonal and 4 space diagonal arcs) at every grid point. By using monochromatic arcs we get [MATH] po... |
Summary We have introduced our GraftalLace Cellular Automaton which makes a one-dimensional infinite monochromatic digraph otherwise an octal number triangle or number trapezoid by partly influences the states of the neighbour cells with bit operations. We have shown new ways to make known symmetric fractal patterns an... |
References. [W84] Wolfram, S.: Computer Software in Science and Mathematics , Scientific American, Vol. 251, Issue 3, September 1984. |
[W02] Wolfram, S.: A New Kind of Science Wolfram Media Inc., 2002 [D86] Dewdney, A. K.: Computer Recreations — of fractal mountains, graftal plants and other computer graphics at Pixar , Scientific American, Dec. 1986 |
[PL90] Prusinkiewicz, P. and Lindenmayer, A.: The algorithmic beauty of plants , Springer, 1990. [WE] Wolfram MathWorld / Elementary Cellular Automaton |
[K17a] Kaszanyitzky, A.: The generalized Sierpiński Arrowhead Curve , 2017 [K17b] Kaszanyitzky, A.: Triangular fractal approximating graphs and their covering paths and cycles , 2017 [OEIS] Sloane, N.J.A.: The On-line Encyclopedia of Integer Sequences |
# Source: arxiv 1805.11873 # Title: Emptiness of Stack Automata is NEXPTIME-complete: A Correction # Sections: all # Downloaded: 2026-03-03T01:49:11.965080+00:00 |
Emptiness of Stack Automata is NEXPTIME-complete: A Correction Abstract A saturation algorithm for collapsible pushdown systems was published in ICALP 2012. This work introduced a class of stack automata used to recognised regular sets of collapsible pushdown configurations. It was shown that these automata form an eff... |
0.1 Outline We begin with the preliminaries in Section 0.2 The complexity of emptiness checking is shown in Section 0.3 0.2 Preliminaries |
We give the definition of higher-order collapsible stacks before describing stack automata. 0.2.1 Higher-Order Collapsible Stacks |
Higher-order collapsible stacks are a nested “stack-of-stacks” structure over a stack alphabet [MATH] . Each stack character contains a pointer — called a “link” — to a position lower down in the stack. The stack operations, defined below, create copies of sub-stacks. The link is intuitively a pointer to the context in... |
[MATH] Definition 0.2.1 (Order- [MATH] Collapsible Stacks) An order- [MATH] link is a tuple [MATH] where [MATH] and [MATH] are natural numbers. If |
[MATH] we say the link is up-to order- [MATH] Given a finite set of stack characters [MATH] , an order- [MATH] stack with an up-to order- [MATH] link is |
[MATH] where [MATH] and [MATH] is an up-to order- [MATH] link. An order- [MATH] stack with up-to order- [MATH] links is a sequence |
[MATH] such that each [MATH] is an order- [MATH] stack with up-to order- [MATH] links. Moreover, for each [MATH] and each order- [MATH] link |
[MATH] appearing on a character in [MATH] , we have [MATH] Let [MATH] denote the set of order- [MATH] stacks with up-to order- [MATH] links. |
In the sequel we will refer to order- [MATH] stacks with up-to order- [MATH] links simply as order- [MATH] stacks. We will use order- [MATH] stack to mean an order- [MATH] stack with up-to order- [MATH] links, where [MATH] is clear from the context. We define the interpretation of the collapse links below. First, we gi... |
[MATH] Intuitively, the collapse links point to a position lower down in the stack. Hence, we can represent collapse links informally with arrows. Our example stack could be written |
[EQUATION] The collapse operation, defined below, will remove all parts of the stack above the destination of the topmost collapse link. Collapse on the stack above gives |
[MATH] Note, we will often omit the collapse link annotations for readability. Given an order- [MATH] stack [MATH] , we define [EQUATION] |
noting that [MATH] is undefined if [MATH] is empty for any [MATH] For technical reasons, we also define [MATH] when [MATH] is an order- [MATH] stack. We remove the top portion of a [MATH] stack using, where [MATH] |
[EQUATION] For [MATH] where [MATH] has the link [MATH] , the destination of the link is [MATH] When [MATH] is a [MATH] -stack and [MATH] is an [MATH] -stack with [MATH] , we define [MATH] as the stack obtained by adding [MATH] on top of the topmost [MATH] -stack of [MATH] . Formally, we let |
[EQUATION] 0.2.2 Regularity of Collapsible Stacks We are interested in regular representations of sets of collapsible pushdown stacks. |
For this we use order- [MATH] stack automata, thus defining a notion of regular sets of stacks. These have a nested structure based on a similar automata model by Bouajjani and Meyer |
. The handling of collapse links is similar to automata introduced by Broadbent et al. , except we read stacks top-down rather than bottom-up. |
Definition 0.2.2 (Order- [MATH] Stack Automata) An order- [MATH] stack automaton [EQUATION] is a tuple where [MATH] is a finite stack alphabet, |
[MATH] are finite disjoint statessets, and 1. for all [MATH] , we have that [MATH] is a transition relation, and [MATH] is a set of accepting states, and |
2. [MATH] is a transition relation, and [MATH] a set of accepting states. Stack automata are alternating automata that read the stack in a nested fashion. Order- [MATH] stacks are recognised from states in [MATH] . A transition [MATH] from |
[MATH] to [MATH] for some [MATH] can be fired when the [MATH] stack is accepted from [MATH] The remainder of the stack must be accepted from all states in [MATH] At order- [MATH] , a transition [MATH] is a standard alternating [MATH] -transition with the additional requirement that the stack pointed to by the collapse ... |
[MATH] is reached at the end of each order- [MATH] stack. In Section LABEL:sec:formal-sa-run , we formally define the runs of a stack automaton. We write |
[MATH] whenever [MATH] is accepted from a state [MATH] . For ease of presentation, we write [MATH] instead of [MATH] and [MATH] instead of [MATH] |
A (partial) run is informally pictured below, reading an order- [MATH] stack using [MATH] and [MATH] Note, the transition [MATH] |
reads the topmost order- [MATH] stack, with the remainder of the stack being read from [MATH] The node labelled [MATH] begins a run on the stack pointed to by the collapse link of [MATH] . Note that the label of this node may contain other elements apart from [MATH] . These additional elements come from the part of the... |
{psmatrix} [nodealign=true,colsep=2ex,rowsep=1.25ex] statesetQ_k-1 ⊆ _k-1 [MATH] [MATH] [MATH] Q’_k⊆ _k-1 [MATH] q_k∈Q_k [MATH] q_kq_k-1→ Q∈Δ_k [MATH] q_k-1 ∈Q_k-1 [MATH] Q⊆Q’_k |
We write [MATH] to denote that the order- [MATH] stack [MATH] is accepted by [MATH] from [MATH] for some [MATH] Similarly, for [MATH] |
for some [MATH] we write [MATH] when [MATH] is accepted from each [MATH] Note, if [MATH] then all stacks are accepted. 0.3 Emptiness of Stack Automata |
In ICALP 2012 we incorrectly stated that the emptiness problem for stack automata was PSPACE-complete. As pointed out by an anonymous reviewer, the algorithm given actually runs in PTIME and does not correctly implement the emptiness test. We show that the problem is, in fact, NEXPTIME-complete. |
Theorem 0.3.1 Let [MATH] and [MATH] be an order- [MATH] stack automaton. Testing whether there exists an order- [MATH] collapsible pushdown stack |
[MATH] such that [MATH] for a given state [MATH] of [MATH] is NEXPTIME-complete. The above theorem is proved in Section 0.3.1 and Section 0.3.2 below. |
0.3.1 Upper Bound The upper bound can be obtained quite easily. We know from ICALP 2012 that stack automata are equivalent to the bottom-up automata introduced by Broadbent et al. |
More formally, we have the following proposition. The complexity is apparent from the proof presented in the paper. Proposition 0.3.1 |
, as Proposition 4) For every order- [MATH] stack automaton [MATH] with initial state [MATH] , there is a bottom-up stack automaton [MATH] of size exponential in the size of [MATH] with initial state [MATH] such that [MATH] |
Then, from Broadbent et al. , we know the emptiness problem for bottom-up stack automata is NP-complete. When applied to an exponentially large automaton, this gives us NEXPTIME as required. |
Proposition 0.3.2 , as Proposition 2) Given fixed [MATH] and some automaton [MATH] , deciding whether there exists some order- [MATH] collapsible stack that it accepts is NP-complete. |
In conclusion, we have the following proposition. Proposition 0.3.3 Emptiness checking of order- [MATH] stack automata is in NEXPTIME. |
0.3.2 Lower Bound The lower bound is by reduction from a tiling problem over a [MATH] grid. It is known that, when [MATH] is given in unary, there is a fixed tiling problem for which the problem in NEXPTIME-hard in the size of |
[MATH] We begin by recalling the definition of a tiling problem before giving the reduction. Tiling Problems Definition 0.3.1 (Tiling Problem) |
tiling problem is a tuple [MATH] where [MATH] is a finite set of tiles, [MATH] is a horizontal matching relation, [MATH] is a vertical matching relation, and |
[MATH] are initial and final tiles respectively. A solution to a tiling problem over a [MATH] -width and [MATH] -height corridor is a sequence |
[EQUATION] where [MATH] [MATH] and for all [MATH] and [MATH] we have [MATH] and for all [MATH] and [MATH] we have [MATH] Note, the grid layout is for presentation purposes only, and the sequence should truly be written |
[MATH] We will assume that [MATH] and [MATH] can only appear at the beginning and end of the tiling respectively. In the sequel we will fix a tiling problem |
[MATH] such that for any [MATH] (in unary) finding a solution to the problem over a [MATH] -width and [MATH] -height corridor where |
[MATH] is NEXPTIME-hard Reduction to Stack Automata Emptiness We first describe the shape of the stacks we wish to see, given a tiling problem as fixed above. Then we will show how to build a stack automaton which recognises such stacks which encode solutions to the tiling problem. For technical convenience, given [MAT... |
[MATH] Encoding Solutions as Stacks We will define an order- [MATH] stack automaton that will only accept stacks of the following form. The notation |
[MATH] for [MATH] is the [MATH] -bit encoding of [MATH] , most significant bit first, using the stack characters [MATH] and [MATH] Collapse links are drawn as arrows and only appear if necessary. Characters without explicit links may have any valid link as they are not needed for the encoding. Note, the grid structure ... |
[EQUATION] That is, the stack begins with three stacks containing only a spacer character [MATH] This is merely for technical reasons as it allows alternating transitions later to get started. On the next row in the diagram we have an order- [MATH] stack for each tile position on the first row of the solution. The next... |
[MATH] and [MATH] and appearing with the most significant bit first. For example [MATH] appears on the stack as [EQUATION] Finally, each [MATH] is a tile. |
Recognising Tiling Solutions We will define an order- [MATH] stack automaton which only accepts valid encodings of solutions to the tiling problem. There are several key properties to assert. |
1. The stack contains a sequence of order- [MATH] stacks, where the topmost three stacks contains only a spacer and subsequent stacks are of the form |
[EQUATION] 2. The fourth topmost order- [MATH] stack contains [MATH] 3. The bottommost order- [MATH] stack contains [MATH] 4. For all but the first three and bottomost order- [MATH] stacks, if the stack contains |
[MATH] then the order- [MATH] stack beneath it contains [MATH] if [MATH] and [MATH] if [MATH] 5. For every order- [MATH] stack containing |
[MATH] with [MATH] the collapse link from [MATH] in the stack leads to an order- [MATH] stack containing [MATH] 6. We have [MATH] |
7. We have [MATH] 8. For every [MATH] and [MATH] we have [MATH] 9. For every [MATH] and [MATH] we have [MATH] There is a stack satisfying the above properties iff there is a solution to the tiling problem. At this point, the experienced reader may see how alternating automata can be used to enforce the above properties... |
Note, if we did not assert Property we could have multiple stacks each with the same index [MATH] If this were the case then Property would not ensure that the collapse links encoded a grid. Thus, our encoding will crucially rely on the width and height being fixed. That is, our encoding will not extend to EXPSPACE Tur... |
We define an order- [MATH] stack automaton recognising only such stacks. In particular, we have [EQUATION] where the alphabet, states, and transitions are defined during the description below. We simultaneously argue for the correctness of the definition. |
Proposition 0.3.4 The tiling problem [MATH] has a solution over a [MATH] corridor iff the order- [MATH] stack automaton [MATH] is non-empty. |
The alphabet is [MATH] The only accepting states are [EQUATION] The initial state is [MATH] and there is a single transition from it which leads to a state for each property above: |
[EQUATION] where [MATH] and [MATH] From [MATH] we simply check the stack contains only a spacer: [EQUATION] We also have a state |
[MATH] that accepts any order- [MATH] stack. From it there is a transition [EQUATION] The remaining properties are more involved. |
1. To check that the stack is of the right basic shape, we have [MATH] with [EQUATION] to recognise the leading spacer stacks, and |
[EQUATION] to recognise the remaining stacks, where [MATH] is a state for asserting the correct shape of order- [MATH] stacks. Observe that the transition to [MATH] can only be and must be used to read the bottommost order- [MATH] stack in any accepting run. |
In particular, we have [MATH] where we first assert the leading spacer [EQUATION] and then that we have [MATH] bits with [EQUATION] |
for all [MATH] and finally a trailing tile with [EQUATION] for all [MATH] 2. To check the topmost non-spacer stack contains [MATH] |
we have [MATH] and [EQUATION] where, to check the order- [MATH] stack we have [MATH] and, for all [MATH] [EQUATION] 3. To check the bottommost order- [MATH] stack contains |
[MATH] we have [MATH] and [EQUATION] where, to check the order- [MATH] stack we have [MATH] and, for all [MATH] [EQUATION] 4. To check the sequence of binary numbers runs from |
[MATH] to [MATH] first notice that we can consider [MATH] as a [MATH] -bit binary number. In this case each stack contains the successor of the stack above it. |
We will make use of the following auxilliary states in [MATH] That is, for all [MATH] we have [MATH] Note, the choice of notation here indicates that we are dealing with [MATH] -bit numbers instead of [MATH] -bit numbers. We will need similar states for [MATH] -bit numbers later. |
Intuitively, these states are used to check that binary encodings succeed each other. Take the two numbers [MATH] and [MATH] We will number bits from right to left, starting at [MATH] Hence, in the first number, the first and second bits are [MATH] , the third is |
[MATH] , the fourth is [MATH] , and the fifth is [MATH] Note the latter binary number is the increment of the former. This can be identified by noticing that the rightmost [MATH] is bit [MATH] In the incremented number, bit [MATH] is now a [MATH] and all bits to the right are now [MATH] Thus, [MATH] will assert that th... |
must be the [MATH] th bit. Now, if one order- [MATH] stack appears directly below the other, the upper stack will be accepted by some [MATH] and the lower stack will be accepted from the corresponding [MATH] |
We will also need to make use of states [MATH] to assert the equality of bits at each position in the binary numbers between the topmost two stacks. From these we will guess what the value of the bits are by moving to states |
[MATH] for all [MATH] The reader may notice here that there is some delay in setting up the right states. For example, to check the equality of bits [MATH] and [MATH] , the automaton first needs to read a stack and move to [MATH] and [MATH] , and then needs to guess the bit values (say [MATH] ) and then, while reading ... |
[MATH] and [MATH] This is why we have leading stacks only containing a spacer, to allow the look ahead to wind up. Thus, as well as checking the immediate stacks, there will be some states for checking the stacks ahead. |
Thus, for each [MATH] we have from [MATH] the transition [EQUATION] Notice, there are only polynomially many such transitions. The state [MATH] appears to assert the sequence property of the next stack. Next, we make another set of transitions to guess the value of the bits to be tested by |
[MATH] For this we have, for all [MATH] [EQUATION] with [MATH] We are now ready to begin testing that the stacks are in sequence. That is, we check the current and succeeding stack all agree on the bits asserted by the states |
[MATH] and [MATH] and the increment of the rightmost [MATH] is done correctly. For this we have the transitions [EQUATION] for all |
[MATH] with [MATH] We delay the description of the order- [MATH] states until we are finished at order- [MATH] (see below). To complete the treatment at order- [MATH] we have transitions that check the successor stack. These are, for all |
[MATH] [EQUATION] We also need transitions which allow the automaton to leave the bottommost stack unchecked (it is checked in the case above). For this we allow all states that should check a stack to simply move to the final state. That is, |
[EQUATION] for all [MATH] There are several properties the above transitions need to assert at order- [MATH] First we have the states |
[MATH] for all [MATH] These states check the rightmost [MATH] appears at position [MATH] We first skip the leading spacer with [EQUATION] |
Then we have, for all [MATH] [EQUATION] and for all [MATH] [EQUATION] and for all [MATH] [EQUATION] Similarly, we check the rightmost [MATH] bit with |
[MATH] for all [MATH] We first skip the leading spacer with [EQUATION] Then we have, for all [MATH] [EQUATION] and for all [MATH] |
[EQUATION] and for all [MATH] [EQUATION] Next, we check that the [MATH] th bit is a [MATH] with the states [MATH] for all [MATH] We first skip the leading spacer with |
[EQUATION] Then we have, for all [MATH] [EQUATION] and for all [MATH] [EQUATION] Similarly for [MATH] and [MATH] 5. To check that the collapse links form a grid, we follow a similar strategy to the previous case, with some differences. Aside from the change in the handling of successors, the main change is that instead... |
[MATH] for all [MATH] From these states we have only the transition [EQUATION] Recall, when following collapse links we need to move from a stack containing |
[MATH] to [MATH] We use a slight modification of the previous strategy for testing the increment of [MATH] , except we restrict the checks to the leftmost |
[MATH] bits. The equality checks are almost the same, except we have to move through the collapse links instead of down the stack. |
Thus, similar to [MATH] and [MATH] we use for all [MATH] the states [MATH] to check the rightmost [MATH] or [MATH] respectively in the leftmost |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.