**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

_{1}, x

_{2}, x

_{3}, ... , 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__(^{2}__a__); and__f__^{ 2}(__a__) <__f__^{ 3}(__a__); and so on:__a__

**<**

__f__(

__a__)

**<**

__f__

^{ 2}(

__a__)

**<**

__f__

^{ 3}(

__a__)

**<**

__f__

^{ 4}(

__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__^{ 2n}(__a__) is a*fixedpoint*for__f__:__f__(__f__^{ 2n}(__a__)) =__f__^{ 2n}(__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__

^{2}(

__i__)

**<**

__F__

^{3}(

__i__)

**<**...

__F__

^{2n}(

__i__) =

__F__(

__F__

^{2n}(

__i__))

__i__generates the “leftmost” fixedpoint. QED.

Similarly,

__j__generates the “rightmost” fixedpoint:__F__(

__F__

^{2n}(

__j__)) =

__F__

^{2n}(

__j__)

All other fixedpoints lie between the two extremes:

__x__=

__F__(

__x__) implies that

__F__

^{2n}(

__i__)

**<**

__x__

**<**

__F__

^{2n}(

__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.
## No comments:

## Post a Comment