Monthly Archives: March 2023

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^j on input a.  Note that this will be some q_i^k for 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_init because 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.