Tag Archives: Linear Bounded Automaton Acceptance

Finite Function Generation

Posted on March 17, 2023 | Leave a comment

We’re moving away from the Perti Net stuff to a simpler problem to describe, though the reduction is pretty convoluted.

The problem: Finite Function Generation. This is problem MS5 in the appendix.

The description: Given a set of functions F whose domains and co-domains are the same finite set A, and a new function h, also from A->A. Can h be created by composing functions from F?

Example: Here’s a pretty simple example. Let A = {0,1,2,3,4,5}

Let F consist of 2 functions: F2(x) = (x+2) mod 6, and F3(X) = (x+3) mod 6

If h is h(x) = (x+1) mod 6, we can get it from F2(F2(F3(x))).

But if we replace F3 with F4 (X) = (x+4) mod 6, then we can never make h, because all combinations of F2 and F4 keep the same odd/even parity of the inputs.

Reduction: Kozen, who has the paper with the reduction on Finite Automata Intersection, uses that problem here as the basis for his reductions. G&J say that the reduction is from Finite Automata Intersection, but since the finite automata we use are the ones created in that reduction, I think it’s more correct to say that this reduction is from LBA Acceptance, since that is where we start with an arbitrary problem instance.

The Finite Automata Intersection reduction started with an arbitrary machine M and an input string w, and made a bunch of finite automata F_i such that M accepts w if and only if there was at least one string in the language of each F₁ (i.e., the intersection of the languages of the machines is non-empty). We’ll label state j of machine i q_i^j. Because they are FA’s, each machine i has one start state (q_i^start), and they were built to have one final state (q_i^final).

Create a set A which will be the set of the states of all machines, plus three extra elements: o₁, o₂, and o₃. Every symbol in the common alphabet of the machines a gets a function f_a:

f_a(q_j^j) = The state we go to from q_i^jon input a. Note that this will be some q_i^kfor some k (some state on the same machine).
f_a(o₁) = o₃
f_a(o₂) = o₂
f_a(o₃) = o₃

It’s worth mentioning that since the machines are DFAs, there is a well-defined transition from each state on each input symbol, so these are functions that provide a single value for each domain element. Also notice that we can compose these functions to build f_w for some string w: f_w(q) = the state we end up in starting in state q on the string w. This means that a machine i accepts a string w iff f_w(q_i^start) = q_i^final.

We’ll add a new function “f_init” to our set of functions. f_init takes elements from A:

f(q) returns q_i^start if q is any state in a machine q_i
f(o₁) = o₂
f(o₂) = o₃
f(o₃) = o₃

Now we’ll build our function h:

h(q) returns q_i^final if q is any state in a machine q_i
h(o_i) = f_init(o_i) for i from 1 to 3.

Suppose that there is a string w in the languages of all of our automata F_i. This would mean that for all machines i, f_w(q_i^start) = q_i^final. It also means that those f functions need to map f_w(o₁) to o₃, f_w(o₂) to o₂, and f_w(o₃) to o_3. We can get this by h = f_w ° f_init.

In the other direction, suppose we can generate h by the composition of our f functions. The first function in the composition has to be f_initbecause all other functions take o₁ to o₃, and then all functions keep o₃ at o₃. This can’t happen because h(o₁) = o₂.

After the first f_init, we can’t have another f_iniit because calling f_init twice would take o₁ to o₂ the first time, and then to o₃ the second time. All of the other f_a functions keep o₂ at o₂. So we know the composition has to be f_init first, then some number of f₁ functions forming a composed f_w.

If h is given any state in a machine as input, it returns the final state of that machine. If f_init is given any state in a machine as input, it returns the start state of that machine. For f_w(f_init(q)) to return qi^final, it must be the case that f_w(q_i^start) = q_i^final, for all i. This gives us a string w that is in the language of each machine.

Difficulty: 8. It’s interesting to see how the functions are made- that there is a function for each input symbol, instead of for each machine, which I, at least, would expect. Also, the use of the various o_i inputs is important, easy to mess up, and hard to come up with.

Reachability for 1-Conservative Petri Nets

Posted on January 27, 2023 | Leave a comment

As promised, here is the next problem, also using Petri nets. I’m not 100% convinced that my definition of “1-Conservative” is accurate, but it seems to work for this reduction.

The problem: Reachability for 1-Conservative Petri nets. This is problem MS4 in the appendix.

The description: A “1-Conservative” Petri net has each transition preserve the number of tokens on each side of the transition, and has at most 1 token per edge. Given such a Petri net and a state M, is there a sequence of transitions that can reach M from the starting state?

Example: I had a hard time finding a non-trivial example of a 1-conservative network. But maybe that’s ok. Here’s another figure from the Murata paper:

There are no tokens in this picture. But notice that if we start with no tokens, no state with tokens is reachable. If we start with a token in the left state, then both 1-token configurations are reachable, but we won’t be able to reach a configuration with 0 tokens or 2 tokens in it.

Reduction: This is Theorem 3.1 in the Jones, Landweber, and Lien paper. The reduction is from Linear Bounded Automaton Acceptance.

So we start with a LBA M, with p tape symbols, and m states. It has an input string $x₁x₂..x_n$. Our task is to build a 1-Conservative Petri Net.

The first set of places in the Petri net will be represented by A_ij, 0 <= i <= n+1, 1 <= j <= p. This will represent the tape. A_ij will have a token iff space i of the tape has symbol j.

We will also have places labeled Q_ij, 0 <= i <= n+1, 1 <= j <= m. This will simulate the states. Q_ij will have a token iff the head is over space i of the tape while the machine is in state j.

We’ll also have 2 special places C and D. Tokens start in all of the A_ij places corresponding to the input string of the tape, and in Q₁₁ (the machine starts in state 1 over cell 1 of the tape).

The transitions in the net are based on the transitions in the machine. If we have a transition from state q_s and symbol a_t to state q_r, writing a symbol a_l we add a transition Q_is + A_it -> Q_jr + A_il for all i. “j” in the destination is either i, i+1, or i-1, depending on if the head stays, moves right, or moves left.

If we are in a final state q_s, we add a transition Q_is->C for all i.

We also add the transition C+A_ij -> C+D.

Note that all transitions have 1 token per edge and preserve the number of tokens, so this is a 1-Conservative Petri net.

Our destination state is:

1 token in C
N tokens in D
1 token in each A_i1

Since all of these transitions simulate the movement in the LBA, if the LBA accepts the string, we follow all of the transitions to eventually put the token in C. This allows us to do the last transition to put the tokens in D.

In the other direction, if we can reach the desired state, we must have put a token in C. To get there, we must have gotten to a final state q_f. Thus, the LBA must have accepted the string (by following the transitions we took in the Petri Net to get to that q_f state).

Difficulty: 7. I like how they can represent all combinations of tape symbols and locations as places. I’m a little worried because it looks like this assumes you’ll never go beyond the end of the input string, where I thought an LBA was allowed to use a linear multiple of the input string’s size. Is there some kind of equivalence proof that says an LBA can only need its own input string’s space exactly?