Re: Universal prior - Go FORTH and Run Backward

From: <GSLevy.domain.name.hidden>
Date: Thu, 11 Nov 1999 18:56:38 EST

In a message dated 11/11/1999 2:04:25 AM Pacific Standard Time,
juergen.domain.name.hidden writes:

>
> An automatic by-product of the Great Programmer's set-up is the
> well-known ``many worlds hypothesis'', (C) Everett III. According
> to it, whenever our universe's quantum mechanics allows for alternative
> next paths, all are taken and the world splits into separate universes.
> From the Great Programmer's view, however, there are no real splits ---
> there are just a bunch of different algorithms which yield identical
> results for some time, until they start computing different outputs
> corresponding to different noise in different universes.
>
Interesting..... However, this approach is tied to the discrete algorithmic
paradigm. Could this Great Programmer operate on a continuum rather than on a
discrete medium? This question has been raised many times in this group and I
would like to explore its implication (for example:. computer language) of a
continuous processor.

The programming style used by all programmers today requires the computer to
follow a discrete, (mostly) unidimensional, unidirectional path which may
include branches and loops. The program may take excursion in a second
dimension such as branches and loops but can never go backward. This
approach however, is by no means compulsory. It is possible to write
compilers for languages that can operate in multidimensions and can even go
backward.

A few years ago I was programming in FORTH (now a defunct computer language)
and, to simplify the implementation of an application program, I modified the
compiler to allow forward as well as backward execution. Forth is unique in
giving you ready access to the compiler. Since then, I rewrote this compiler
in "C" (about 5 pages of programming including the FORTH interpreter and
test cases). Because of FORTH inherent simplicity - it is a reverse polish
language - writing compilers in this language is not difficult. In my
bidirectional compiler all control structures such as IF statements and loops
were bidirectional - that is capable of execution in the forward as well as
in the backward direction. Branches for example, could take this form
---<===>---- and execution could be from right to left or from left to right.
The written statement for a bidirectional IF would be:
    ......
    Forth_Word
    Forth_Word
    FIF (Forward IF)
    Forward_Condition
    FTHEN (Forward THEN)
    True Clause
    Else
    False Clause
    BTHEN (Backward Then)
    Backward_Condition
    BIF (Backward IF)
    Forth_Word
    Forth_Word
    .....

The abiltity of each FORTH word to go backward was simply achieved by popping
the return stack, decrementing its value by 2 and pushing it back again. Upon
return from subroutine, the execution would then resume at the PREVIOUS word,
not at the NEXT word. Control for forward or backward execution was embedded
in the application itself, and mediated by the compiler. The same type of
approach can be used to implement Loops and Case statements, which I have
done.

There is no doubt in my mind that the same approach can also be employed to
create a multidimensional multidirectional discrete programming language. Its
application may be in parallel processing.

Pushing beyond the world of discrete programming, the question arise, is it
possible to create languages for the control of:

1) a unidimensional unidirectional continuous computer.

2) a multidimensional multidirectional continuous computer. This particular
version could be implemented by means of an electromagnetic or quantum wave
travelling in a nonlinear 3-dimensional medium.

What would these languages be like? How would they be written and stored?
What would be their use?

Exploring these issues may help us break beyond the limitations set by Turing
Machines.

George
Received on Thu Nov 11 1999 - 16:04:01 PST