@MSGID: 1@dont-email.me> 7ed7e84c
@REPLY:
<cc7dff2c-dbdd-4888-ba71-3c122993fd01n@googlegroups.com> f9e2a473
@REPLYADDR olcott <polcott2@gmail.com>
@REPLYTO 2:5075/128 olcott
@CHRS: CP866 2
@RFC: 1 0
@RFC-Message-ID: 1@dont-email.me>
@RFC-References:
<cba4f733-5232-4ec4-9a16-ff5828e84b8cn@googlegroups.com> <cc7dff2c-dbdd-4888-ba71-3c122993fd01n@googlegroups.com>
@TZUTC: -0500
@PID: Mozilla/5.0 (Windows NT 10.0; Win64; x64;
rv:102.0) Gecko/20100101 Thunderbird/102.14.0
@TID: FIDOGATE-5.12-ge4e8b94
On 10/19/2022 5:46 PM, Rock Brentwood wrote:
> On Tuesday, December 28, 2021 at 1:11:43 AM UTC-6, Jeffrey Rubard wrote:
 >> Maybe not everyone knows that `Turing-complete` programming
languages have several other models equivalent to the Turing machine. Could
you `rate` the different formalisms?
>> 1) Turing Machines
>> 2) Lambda Calculus
> 
> Lambda Calculus with infinitary terms (and the conditional operator).
> Notation: x = A, B means (lambda x B) A
> Notation: A? B: C is B is A is true and is C if A is false
> Example 1:
 > x = 0, y = 1, x < n? (x = x + 1, y = y*x, x < n? (x =
x + 1, y = y*x, x < n? (...): y): y): y
 > where the infinitary term denoted by (...) is an exact replica
of (x = x + 1, y = y*x, x< n? (...): y).
> 
 > The value of this expression is n!, the factorial of n, assuming
that n is a non-negative integer.
> The value is 1, if n is a negative integer.
> 
 > Notation: Use L: E as a way to denote the (possibly infinitary)
subexpression E by the label L
 > Notation: Use "goto L" as a way to refer to the subexpression
that the label L denotes
> Example 2:
> x? (y? (z? A: B): C): (z? A: B)
> may be rewritten as
> x? (y? goto W: C): goto W
> W: z? A: B
> 
> Example 3: Example 1 rewritten with labels and gotos
> x = 0, y = 1, goto Z
> Z: x < n? (x = x + 1, y = y*x, goto Z): y

For my purposes the best formalism would be a variation of a RASP
machine because this could form a bridge between Turing machines and
high level languages.

The problem with low level languages such as the Turing Machine
description languages is that they make understanding the underlying
algorithm specified in this language infeasibly difficult for any
complex algorithms.

When we understand that relative addressing can provided access to
unlimited memory then the x64 RIP addressing mode defines an abstract
machine with unlimited memory.

We don`t even need this for all algorithms that don`t need more memory
than the amount of memory that is available.


-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

 --- Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.14.0
 * Origin: A noiseless patient Spider (2:5075/128)
SEEN-BY: 5001/100 5015/255 5019/40 5020/715 848
1042 4441 12000 5030/49 1081
SEEN-BY: 5058/104 5075/128
@PATH: 5075/128 5020/1042 4441