## Thursday, August 27, 2015

### n-ary functions and argument lists

Suppose we have a binary operation `Op2 = (lambda (left right) ...)`. If it is closed over some type, you can make expression trees.
```(Op2 (Op2 <arg1> <arg2>)
(Op2
(Op2 <arg3> <arg4>)
<arg5>))```
If `Op2` is associative as well, these are equal:
```(Op2 (Op2 <arg1> <arg2>)
(Op2 <arg3>
(Op2 <arg4> <arg5>)))

(Op2 <arg1>
(Op2 (Op2 <arg2> <arg3>)
(Op2 <arg4> <arg5>)))```

This makes the tree structure irrelevant so long as the fringe of the tree stays in order, so we can flatten the tree by making an N-ary version of the binary operation:
```(define (binary->nary Op2)
(lambda (a1 a2 . an)
(fold-left Op2 (Op2 a1 a2) an)))

((binary->n-ary Op2) <arg1> <arg2> <arg3> <arg4> <arg5> <arg6> etc.)```
The value of this expression naturally depends upon the values of the arguments. Changing the argument list is highly likely to change the value of the entire expression. However, we can make certain changes to the argument list without changing the value of the entire expression. If we know what those changes are, we can manipulate the argument list before invoking the operator, and still get the same answer. Naturally, most of the changes we can make to the argument list depend on the specifics of `Op2`, but it turns out that some interesting changes are possible without knowing any specifics, only knowing a few high-level properties of `Op2`.

Obviously, the first thing we can do is reduce the argument list through evaluation. Simply replace the first two arguments with the value of `(Op2 <arg1> <arg2>)`
```((binary->n-ary Op2) <arg1> <arg2> <arg3> <arg4> <arg5> <arg6> etc.) =

((binary->n-ary Op2) (Op2 <arg1> <arg2>) <arg3> <arg4> <arg5> <arg6> etc.) =

((binary->n-ary Op2) <result> <arg3> <arg4> <arg5> <arg6> etc.)```
Since `Op2` is associative, we can replace any 2 adjacent arguments with their combination.

Now suppose there is an identity element among the arguments we can give to Op2.
```(Op2 <arg> id) = <arg>  and
(Op2 id <arg>) = <arg>```
We can do this:
```(define (binary->nary Op2)
(lambda an
(fold-left Op2 id an)))

(define Op (binary->nary Op2))```
Which is cleaner than the original. We also get a new way to manipulate the argument list to `Op`. We can add the identity element anywhere we wish, or we can delete the identity element wherever we find one.
```(Op <arg1> <arg2> <arg3> Id <arg4> <arg5> <arg6> etc.) =

(Op <arg1> <arg2> <arg3> <arg4> <arg5> <arg6> etc.) =

(Op <arg1> Id <arg2> <arg3> <arg4> <arg5> Id <arg6> etc.)```

One more restriction. We want `Op2` to be invertible. Suppose `(Op2 <arg1> <arg2>) = <result>`. `Op2` is invertible if, given any two of <arg1>, <arg2>, and <result>, the third can be uniquely determined. If you have one <arg> and a <result>, you can run things backwards and get the other <arg>.

Requiring `Op2` to be invertible has many consequences, some of them quite non-obvious. An obvious consequence, though, is that we can define inverse elements. If `(Op2 <argA> <argB>) = Id`, then we say that <argB> is the inverse of <argA> (and vice versa). We find the inverse of an argument by fixing the output as the identity element and running `Op2` backwards to find the other argument.

This gives us the final way to manipulate the argument list. If an element appears next to its inverse, both can be removed:
```(Op <arg1> <arg2> <arg3> (inverse <arg3>) <arg5> <arg6> etc.) =
(Op <arg1> <arg2> (Op2 <arg3> (inverse <arg3>)) <arg5> <arg6> etc.) =
(Op <arg1> <arg2> Id <arg5> <arg6> etc.) =
(Op <arg1> <arg2> <arg5> <arg6> etc.)```

So here are all the restrictions on Op2:
• Closed over an set of arguments
• Associative
• Has an identity argument
• Invertible
If `Op2` has these properties (and a lot of binary operations do), then we can define an n-ary `Op` and play with its argument list. If you do this, you might notice that it looks kind of familiar:
`(op f g (inverse g) j id h) = (op f j id h) = (op f j h)`

The argument list sort of looks like a function pipeline. The allowed manipulations of the argument list are compatible with a function pipeline, too. In fact, it could be a function pipeline if `Op` is the `compose` operator, and `f`, `g`, and `h` are appropriate invertible unary functions. But whatever it is, the point is that it looks enough like a function pipeline that we can pretend that it is.

## Sunday, August 23, 2015

### Playing with linear fractional transforms

I wanted to play with continued fractions and linear fractional transforms, so I wrote some code to make it easier. A linear fractional transform (also called a homographic function or Mobius transform) is a function like this:
In MIT/GNU Scheme:
```;; x => (3x + 1)/(x + 4)

1 ]=> (define foo (make-linear-fractional-transform 3 1 1 4))

;Value: foo

1 ]=> (foo 2)

;Value: 7/6
```
I used an entity object so, in addition to invoking it on a number, there are two more ways to manipulate a linear fractional transform:
```;; A predicate
1 ]=> (linear-fractional-transform? foo)

;Value: #t

;; And a CPS accessor
1 ]=> (lft/spread-coefficients foo (lambda (A B C D) (list A B C D)))

;Value 307: (3 1 1 4)
```
I also added a print method:
```1 ]=> foo

;Value 308: #[linear-fractional-transform 308 (3x + 1)/(x + 4)]
```

As I mentioned in a prior post, you can partly apply a linear fractional transform:
```1 ]=> foo

;Value 308: #[linear-fractional-transform 308 (3x + 1)/(x + 4)]

1 ]=> (lft/partly-apply foo 2)

;Value 315: #[linear-fractional-transform 315 (7x + 3)/(6x + 1)]
```
Since I want to reason about applying a linear fractional transform to an argument, I wrote an abstraction for that:
```;; Apply LFT foo to continued fraction phi.
1 ]=> (make-lft-application foo phi)

;Value 311: #[lft-application 311 (3x + 1)/(x + 4) {1 ...}]
```
So now we can write a procedure that takes an application, peels off the first term in the continued fraction, feeds it to the linear fractional transform, and creates a new application:
```(define (application/step lft-application)
(let ((lft (application-function lft-application))
(cf  (application-continued-fraction lft-application)))
(make-lft-application
(tail cf))))

1 ]=> (define appl (make-lft-application lft/identity sqrt-two))

;Value: appl

1 ]=> appl

;Value 317: #[lft-application 317 x {1 2 2 2 ...}]

1 ]=> (application/step appl)

;Value 318: #[lft-application 318 (x + 1)/x {2 2 2 ...}]

1 ]=> (application/step (application/step appl))

;Value 319: #[lft-application 319 (3x + 1)/(2x + 1) {2 2 ...}]

1 ]=> (application/step (application/step (application/step appl)))

;Value 320: #[lft-application 320 (7x + 3)/(5x + 2) {2 ...}]
```
All these `lft-application` objects should be (numerically) equal.

In an earlier post I showed how a linear fractional transform can be partly evaluated by determining the `integer-part` of the transform. The `integer-part` of an application is the `integer-part` of the application-function. You can get the fractional part by subtracting the integer-part.

### A digression

If you apply a linear fractional transform to zero, it's obvious the answer is `B/D`. On the other hand, if you apply a transform to a sufficiently large x, you'll get as close as you want to `A/C`.

If the denominator of a linear fractional transform is zero for some value of x, there should be a vertical asymptote at that point. That's the pole of the transform. The pole is at `(- D)/C`. The pole will be at zero if `D` is zero. It will be at a negative number if D and C are the same sign and at a positive number if D and C differ in sign.

If you take a linear fractional transform with a pole at a negative number, and you sweep the input from 0 up on to infinity, the output will vary smoothly and monotonically from `B/D` approaching `A/C` and staying between both values at all times.
```1 ]=> lft1

;Value 675: #[linear-fractional-transform 675 (3x + 1)/(4x + 2)]

1 ]=> (lft1 0)

;Value: 1/2

1 ]=> (lft1 1000000)

;Value: 3000001/4000002

1 ]=> (exact->inexact 3000001/4000002)

;Value: .7499998750000625
```

(On the other hand, if the pole is at a positive number, as you sweep the input from 0 up to infinity, the output starts at `B/D`, but flees away from `A/C` until the input gets to the pole. Then the output approaches `A/C`, but from the opposite direction. In any case, if the pole is positive, then the output will vary from `B/D` and eventually approach `A/C`, but never being between them.)

We can represent intervals as linear fractional transforms. The endpoints of the interval are `A/C` and `B/D`.

To get the width of the interval, just subtract the endpoints: `A/C - B/D = (A*D - B*C)/(C * D)`

Imagine you are performing some calculation with continued fractions. Since there may be an infinite number of terms, the calculation will proceed incrementally, using up terms as needed and generating other terms. So you can think of a more complex calculation as a tree, where a node in the tree is a linear fractional transform and the continued fraction terms flow between the nodes.

When we do an `application/step`, we move a term from the continued fraction into the linear fractional transform. Now consider a term as an element of information. We've moved this information out of the continued fraction and into the linear fractional transform. The information is apparently "stored" in the linear fractional transform until it is extracted as an output term for the next stage in the computation. But if you think about it, the "format" of the information is different depending upon whether it is flowing between nodes, where it is a series of continued fraction terms, or if it is stored in a linear fractional transform, where it is encoded somehow in the values of the coefficients. The act of partly-evaluating a linear fractional transform is in effect "encoding" some information as a continued fraction term. Partly applying a linear fractional transform is in effect "decoding" the continued fraction term (presumably generated by an earlier computation). Why not change to a more efficient communication channel?

When a node sends information to another node, instead of converting the information to several continued fraction terms to be assembled at the other end, we'll send the information as a single linear fractional transform. It contains the desired information already in the right "format". (See Peter Potts's work.)

### A digression

What happens if we compose two linear fractional transforms?
```(compose (lambda (x)
(/ (+ (* A x) B)
(+ (* C x) D)))
(lambda (y)
(/ (+ (* p y) q)
(+ (* r y) s))))```
We get
```(lambda (x)
(/ (+ (* A (/ (+ (* p x) q)
(+ (* r x) s))) B)
(+ (* C (/ (+ (* p x) q)
(+ (* r x) s))) D)))```
Which, after some algebra, turns into this:
```(lambda (x)
(/ (+ (* (+ (* A p) (* B r)) x) (+ (* A q) (* B s)))
(+ (* (+ (* C p) (* D r)) x) (+ (* C q) (* D s)))))```
Which is equivalent to this:
```(lambda (x)
(let ((E (+ (* A p) (* B r)))
(F (+ (* A q) (* B s)))
(G (+ (* C p) (* D r)))
(H (+ (* C q) (* D s))))

(/ (+ (* E x) F)
(+ (* G x) H))))```
Which you can see is another linear fractional transform.

If we have a linear fractional transform
```(lambda (x)
(/ (+ (* A x) B)
(+ (* C x) D)))```
It's inverse (if it has one) is:
```(lambda (x)
(/ (+ (* D x) (- B))
(+ (* (- C) x) A))))```
Which is yet another linear fractional transform. These things are everywhere.

Let's see, if we have a binary operation `binop` that is
1. Closed over some set, i.e. given any two elements of the set, the operation applied to the elements produces another element of the set. In other words, `binop` takes two arguments, returns one value, and the type of both arguments and return value are the same.
2. Associative, i.e. `(binop a (binop b c)) = (binop (binop a b) c)`
3. Has an identity argument. A "left identity" is an argument such that `(binop left-identity x) = x`. A "right identity" is an argument such that `(binop x right-identity) = x`. An "identity" argument works as a left or right identity.
4. Is invertible, i.e. for any objects a and b, there is a unique object x such that `(binop a x) = b` and a unique object y such that `(binop y b) = a`

then we have a group.

The `compose` function is a binary operation. When you compose a linear fractional transform with another, you get a third linear fractional transform.
```1 ]=> (define lft1 (make-linear-fractional-transform 3 1 4 2))

;Value: lft1

1 ]=> (define lft2 (make-linear-fractional-transform 5 1 1 0))

;Value: lft2

1 ]=> (lft/compose lft1 lft2)

;Value 662: #[linear-fractional-transform 662 (16x + 3)/(22x + 4)]
```
Linear fractional transforms are associative.
```1 ]=> (define lft3 (make-linear-fractional-transform 7 2 1 3))

;Value: lft3

1 ]=> (lft/compose lft1 (lft/compose lft2 lft3))

;Value 663: #[linear-fractional-transform 663 (115x + 41)/(158x + 56)]

1 ]=> (lft/compose (lft/compose lft1 lft2) lft3)

;Value 664: #[linear-fractional-transform 664 (115x + 41)/(158x + 56)]

```
The linear fractional transform `(make-linear-fractional-transform 1 0 0 1)` is both a left and right identity when composed with another linear fractional transform.
```1 ]=> (define lft/identity (make-linear-fractional-transform 1 0 0 1))

;Value: lft/identity

1 ]=> (lft/compose lft/identity lft1)

;Value 665: #[linear-fractional-transform 665 (3x + 1)/(4x + 2)]

1 ]=> (lft/compose lft1 lft/identity)

;Value 666: #[linear-fractional-transform 666 (3x + 1)/(4x + 2)]
```
Given lft1 and lft2, there is a unique linear fractional transform x such that `(compose lft1 x) = lft2`, and a unique linear fractional transform y such that `(compose y lft1) = lft2`. x should be `(compose (inverse lft1) lft2)`, and y should be `(compose lft2 (inverse lft1))`
```1 ]=> lft1

;Value 675: #[linear-fractional-transform 675 (3x + 1)/(4x + 2)]

1 ]=> lft2

;Value 687: #[linear-fractional-transform 687 (5x + 1)/x]

1 ]=> (define x (lft/compose (lft/inverse lft1) lft2)))

;Value: x

1 ]=> (lft/compose lft1 x)

;Value 690: #[linear-fractional-transform 690 (5x + 1)/x]

1 ]=> (define y (lft/compose lft2 (lft/inverse lft1)))

;Value: y

1 ]=> (lft/compose y lft1)

;Value 691: #[linear-fractional-transform 691 (5x + 1)/x]
```
It sure looks like linear fractional transforms form a group under function composition.
I guess it's time to learn a little group theory.