This paper (also referenced in our last problem) is the first one in the Bibliography whose first author started with “T”. It feels weird that it took so long to get that letter. Now the only letters missing in the Bibliography are “Q” (though I have a direct proof from Maurice Queyranne in the K-Closure post), “X”, and “Z”. I’m not sure I’ll get any “X” or “Z” papers, we’ll see.

**The problem: **Inequivalence of Simple Functions. This is problem PO15 in the appendix.

**The description: **A simple function is a composition of basic functions on non-negative integers from:

- s(x) = x+1
- plus(x,y) = x+y
- sub(x) = x-1
- select
_{i}(x_{1}..x_{n}) = x_{i} - div(x,t) = [x/t] (integer division where t is a constant positive integer)
- w(x,y) = if(y == 0) then x else 0
- mod(x,t) = The remainder of dividing x by t (t is a constant positive integer)

We are given two simple functions f and g over some set of initial variables X. Can we provide starting values in X that give different outputs for f and g?

**Example:**

Let

f(x,y) = s(s(s(x)))

(This returns x+3)

g(x) = s(s(s(w(x,y))))

(This returns x+3 if y is 0, but 3 if y is not 0)

On any input pairs (x,y) where y is 0, f and g will return the same value. But the functions are inequivalent because f(2,7) = 5 but g(2,7) = 3.

**Reduction: **Tsichritzis uses Inequivalence of Loop Programs Without Nesting, which we did last time. The idea is to show that all such program actually define simple functions (and so therefore if we can find the simple function derived from a program, that is our reduction).

First, he shows that a program without loops either returns x_{i} + k, or k, where x_{i} is some variable and k is a constant. The idea is that since we can only do three things, each command can be rewritten from the top down:

- If the instruction you are looking at is an assignment X=Y, then replace that with X=A (where A is whatever value Y is. Either it has been computed previously in the program, or is Y’s starting value
- If the instruction you are looking at is an increment X=X+1, then replace that with X=A+1, (where A is whatever the previous value of X is. Either it has been computed previously in the program, or is X’s starting value)
- If the instruction is X=0, then remember that 0 is the most recent previous value of X.

At the end, we look at what the output variable has been updated to. It can only have been changed by some amount of additions to some variable’s start value, or by some amount of additions to 0.

So what is left is what goes on inside a loop. Since loops cannot be nested, we know that the body of the loop only has the basic instructions. Thus, all a loop can do is, for each variable Y_{i}:

- Leave it alone, so, if y
_{i}was the contents of the variable at the beginning of the loop, Y_{i}= y_{i}at the end of the loop. - Reset the value to some new constant k
- Set it to some other variable Y
_{j}‘s initial value y_{j}plus some constant k. We’ll say in this case that variable Y_{i}links variable Y_{j}

It’s possible for this set of linking to form a cycle. It’s also possible for variables to depend on variables inside a cycle, but not to be in the cycle themselves. The third possibility is for as variable to not care about a cycle at all and be independent. The values of the independent variables are easy to express as simple functions.

If we have a cycle, the paper shows how the changes to the variable in one iteration can get added together by everything in the cycle, and then multiplied by the number of iterations the cycle goes. These can also be represented as simple functions.

**Difficulty: **6 The actual task we’re trying to do (“represent this program as a simple function”) is pretty easy to see. The details of how to write the simple functions are pretty finicky, though.