Diamond Bracket Forms and How to Count to Two; 4 of 10

From "Cybernetics & Human Knowing", Vol. 24 (2017), No. 3-4, pp. 161-188

3. Phase Order and Fixedpoints

Recall “phase order”:

x < y        iff         x min y  =  x        iff         x max y  =  y

T

<        <

I        <        J

<        <

F

This structure is a lattice; and it is preserved by any diamond-logic function:

a < b     implies    F(a)  <  F(b)

We can extend < to form vectors:

x   =    ( x₁, x₂, x₃, ... , x_n )

x  <  y   if and only if   ( x_i < y_i ) for all i

Given any diamond-logic function f(x), define

a left seed for f is any vector a such that     f(a) < a;

a right seed for f is any vector a such that    a < f(a).

a fixedpoint for f is any vector a such that    a  = f(a).

A fixedpoint is both a left seed and a right seed.

Right seeds generate fixedpoints, thus:

If a is a right seed for f, then  a < f(a). Since f is diamond-logic, it preserves order; so f(a) < f²(a); and f ²(a) < f ³(a); and so on:

a  <  f(a) < f ²(a) <  f ³(a) < f ⁴(a) _ ...

If f has n dimensions, then each component can move at most two steps right before stopping, so the form vector must reach its right bound within 2n steps.

Therefore f ²ⁿ(a) is a fixedpoint for f:   f(f ²ⁿ(a))  =   f ²ⁿ(a)

This is the leftmost fixedpoint right of a.

Right seeds grow rightwards towards fixedpoints.  Similarly, left seeds grow leftwards towards fixedpoints.

All fixedpoints are both left and right seeds - of themselves.

The Self-Reference Theorem:

Any self-referential diamond-logic system has a fixedpoint:

F(x) = x

Proof: Recall that all diamond-logic functions preserve order.

i is the leftmost set of values, hence this holds:

i     <    F(i)

Therefore, i is a right seed for F:

i   <  F(i)  <  F²(i)  <  F³(i)  < ... F²ⁿ(i)  =   F(F²ⁿ(i))

i generates the “leftmost” fixedpoint.  QED.

Similarly, j generates the “rightmost” fixedpoint:

F(F²ⁿ(j))      =       F²ⁿ(j)

All other fixedpoints lie between the two extremes:

x = F(x)       implies  that      F²ⁿ(i)  <   x   <   F²ⁿ(j)

I call this process “productio ex absurdo”; literally, production from the absurd; in contrast to “reduction to the absurd”, boolean logic’s refutation method. Diamond logic begins where boolean logic ends.

To see productio ex absurdo in action, consider this system:

A  =   false

B  =   if B then A

C  =   A or not A

D  =   A but C

E  =   C but A

F  =   D or not D

G  =   E or not E

H  =   F and G

If we iterate this system from default value i, we get:

(A,B,C,D,E,F,G,H) =   (i,i,i,i,i,i,i,i)

è  (f,i,i,i,i,i,i,i)

è  (f,i,t,f,i,i,i,i)

è  (f,i,t,j,i,t,i,i)

è  (f,i,t,j,i,j,i,i)

è  (f,i,t,j,i,j,i,f)

=   fixedpoint.

If we had started from default value j, we would have gotten the rightmost fixedpoint (f,J,t,j,i,j,i,f). These are the only two fixedpoints.