Tag Archives: Difficulty 7

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?

Betweenness

Posted on December 7, 2022 | Leave a comment

The last section is on “Miscellaneous” problems. There are some weird ones in here, but we start with a pretty straightforward number problem.

The problem: Betweenness. This is problem MS1 in the appendix.

The description: Given a set C of triples (a,b,c), where each element of each triple comes from a superset A, can we find an ordering of the elements of A such that according to that ordering, each triple is in either increasing or decreasing order?

Example: It’s actually hard to do a good example for this because most groups of symbols (digits, letters, subscripts, …) have an implicit ordering of elements, and to go against that would be confusing. Having random symbols without connotations of meaning gets pretty confusing pretty quickly as well.

So let’s lean in and say A = {a,b,c,d,e,f} and our triples are:

(a,d,f)
(f,d,b)
(h,d,a)
(f,g,h)
(d,f,h)

We’re allowed any ordering of the elements of A, and the “normal” lexicographical one with ‘a’ first and ‘f’ last satisfies the betweenness rules.

But now suppose we add the new triple: (b,a,d). That is an illegal triple in our normal order, but if we change our ordering so that ‘b’ is first and ‘a’ is second, we can still satisfy all of the triples.

Reduction: The paper by Opatrny uses Hypergraph 2-Colorability (which we called “Set Splitting”). Recall that our reduction only made sets of size 3, so we can start with an instance where each set has at most 3 elements (or, each hyperedge connects at most 3 vertices).

So, suppose we have a set of N vertices s₁..s_n, a set of J 3-vertex hyperedges (a_i, b_i, c_i), as well as M 2-vertex “regular” edges (d_i, e_i).

Our first job is to build superset A. It has:

One symbol for each vertex,
A new symbol X.
A set of J new symbols Y_k, one for each 3-vertex hyperedge.

Now we build C.

Each hyperedge (a_k, b_k, c_k) generates two triples: (a_k, Y_k, b_k) and (Y_k, X, c_k)
Each two-vertex edge (d_k, e_k) generates the triple (d_k, X, e_k)

Suppose the graph had a 2-coloring. Recall that meant that each vertex had a color (the paper uses red and blue) so that each edge and hyperedge touches vertices of both colors. We need to make an ordering of A that satisfies all triples. The ordering will have positive, negative, and rational ranks.

X has rank of 0.
If vertex s_i is red, its rank is i. If it’s blue, its rank is -i.
Each Y_i was associated with a hyperedge (a_i, b_i, c_i).
- If a_i and b_i have the same color (and so the same sign), Y_i‘s rank is min(rank(a_i), rank(b_i)) + $\frac{1}{i+1}$ .
- If they have different colors, the rank is $\frac{1}{i+1}$ if c_i is blue, and $-\frac{1}{i+1}$ if c_i is red

So, suppose every edge had 2 colors. We know:

If a_i and b_i are the same color, they are the same sign, and Y_i is between them, satisfying the (a_k, Y_k, b_k) triple.
If a_i and b_i are the same color, c_i must be the other color (and the other sign from Y_i), satisfying the (Y_k, X, c_k) triple.
If a_i and b_i are different colors, they are different signs. Setting Y_i to a value between 1 and -1 satisfies the (a_k, Y_k, b_k) triple.
If a_i and b_i are different colors, c_i can be either color, so making Y_i the opposite sign as c_i satisfies the (Y_k, X, c_k) triple.
An edge with just 2 vertices needs both vertices opposite colors, and thus opposite signs, so the (d_k, X, e_k) triple is satisfied.

So far, so good. In the opposite direction, suppose we have a solution to the betweenness instance. We’ll assign colors to vertices such that a vertex’s color is red if its rank is > X’s rank. Otherwise, it will be assigned blue. Our triples will now allow any set of a_i, b_i, and c_i to all be greater than or less than X (or for both d_i and e_i to be greater than or less than X), which means that every edge in the hypergraph has both a red and a blue vertex.

Difficulty: 7. It’s relatively easy to see what you need to do. It’s harder to make the numbers actually work. Even this paper has to resort to using rational numbers for the ranks, which is a fixable problem, but certainly not obvious.

Non-Containment for Free B-Schemes

Posted on October 26, 2022 | Leave a comment

Here is another scheme problem with a different kind of a reduction.

The problem: Non-Containment for Free B-Schemes. This is problem PO18 in the appendix.

The description: A “B-Scheme is” a rooted, directed, acyclic graph where each vertex has outdegree of either 0 (a “leaf”) or 2 (a “test”). The test vertices label their out edges as “T” or “F”. Each vertex gets a label. Test vertices are labeled as boolean Boolean variables, leaves are labeled with function symbols (with the special symbol “Ω” meaning “undefined function”.

Multiple vertices can have the same label, but in a “free” B-scheme, no path from the root to a leaf hits two vertices with the same label. We can “assign” truth values to the boolean variables, which then define a path through the scheme to a leaf. The value of the truth assignment is the label given to the leaf we end up in.

Suppse we have two such B-Schemes, S₁ and S₂. S₁ is contained in S₂ if for all assignments of variables, either S₁ ends up in Ω, or S₁ ends up in a leaf that is the same label as S₂‘s leaf with the same assignment.

So, our question is: Given two free B-Schemes S₁ and S₂, is S₁ not contained in S₂?

Example:

Here is our S₁:

“O” is the label for the Ω leaf

Here is S₂

(x1a and x1b both are labeled for the variable x1. I had to give them different names so Graphviz didn’t think they were the same variable.)

S₂ returns the number of true assignments of x0 and x1. S₁correctly finds the same leaf if at least one variable is true, but goes to O otherwise.

But, S₁ is NOT contained in S₂ because assigning both variables to true puts S₁ in L1 and S₂ in L2.

Reduction: The paper by Fortune, Hopcroft, and Schmidt defines this problem and reduces from 3SAT. First, we replace all positive occurrences of the same variable x_i with new variables u_i1..u_ip (if it occurred p times). We similarly replace all negative occurrences of x_i with v_i1..v_iq (if it appeared negated q times). Our job is to build two schemes.

S₁‘s job is to tell us if the formula is satisfiable. Each clause (a₁,b₁, c₁), gets a chain of vertices. It goes “across” on F, and down to the first variable of the second clause on T. If all literals get assigned F, we end up in a Ω leaf. The final clause has edges from T to our output “f” leaf (Yes, that means the vertex we reach when the formula is satisfiable and all of the clauses are true is labeled “f”. I’m sorry.) Here is the paper’s example. Keep in mind that each of the a,b, and c vertices here represent literals whose actual value in the formula is one of the u and v variables we created above.

S₂‘s job is to make sure that all of our new u and v vertices have the same (and consistent) truth values. If we ever have a u_i with a different truth value than some other u_j (or if it has the same truth value as its corresponding v_j) we jump to f. If everything is ok, we jump to a new end point g. Here is the diagram from the paper. Notice that they are doing this for all of the replacements for all of the variables in one scheme.

If our original formula was satisfiable, we would find a way to make S₁ go to f, and since all of the variable assignments are consistent, we could use those assignments to make S₂ go to g, so S₁ is not contained in S₂, In the other direction, if S₁ is not contained in S₂, then since all S₁ can reach is Ω and f, it must be the case that there is an assignment that leads S₁ to f and S₂ to g. S₂ ends in g only when its u and v variables are assigned consistently. S₁ goes to f only when its clauses are all satisfied. Thus, we have found a way to satisfy the formula.

Difficulty: 7. This is different from the other scheme problems we have seen, where the second scheme is the trivial “yes” scheme. Here, we need to use both schemes to check different aspects of the solution. That’s pretty cool.