Richard KEEPS TRYING to get away with this falsehood

On 5/10/2024 9:18 AM, Richard Damon wrote:

On 5/9/24 11:10 PM, olcott wrote:

On 5/9/2024 9:31 PM, Richard Damon wrote:

On 5/9/24 11:38 AM, olcott wrote:

On 5/8/2024 8:38 PM, immibis wrote:

On 8/05/24 21:05, olcott wrote:

On 5/8/2024 10:13 AM, Mike Terry wrote:

On 08/05/2024 14:01, olcott wrote:

On 5/8/2024 3:59 AM, Mikko wrote:

On 2024-05-07 19:05:54 +0000, olcott said:
>

On 5/7/2024 1:54 PM, Fred. Zwarts wrote:

Op 07.mei.2024 om 17:40 schreef olcott:

On 5/7/2024 6:18 AM, Richard Damon wrote:

On 5/7/24 3:30 AM, Mikko wrote:

On 2024-05-06 18:28:37 +0000, olcott said:
>

On 5/6/2024 11:19 AM, Mikko wrote:

On 2024-05-05 17:02:25 +0000, olcott said:
>

The x86utm operating system: https://github.com/plolcott/x86utm enables
one C function to execute another C function in debug step mode.
Simulating Termination analyzer H simulates the x86 machine code of its
input (using libx86emu) in debug step mode until it correctly matches a
correct non-halting behavior pattern proving that its input will never
stop running unless aborted.
>
Can D correctly simulated by H terminate normally?
00 int H(ptr x, ptr x)  // ptr is pointer to int function
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12 }
>
*Execution Trace*
Line 11: main() invokes H(D,D);
>
*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
>
The above execution trace proves that (for every H/D pair of the
infinite set of H/D pairs) each D(D) simulated by the H that this D(D)
calls cannot possibly reach past its own line 03.

>
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything.
>

>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).

>
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.

>

>
This template defines an infinite set of finite string H/D pairs where each D(D) that is simulated by H(D,D) also calls this same H(D,D).
>
These H/D pairs can be enumerated by the one to ∞ simulated steps of D and involve zero to ∞ recursive simulations of H simulating itself simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
>
1st element of H/D pairs 1 step  of D  is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
>
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
>
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
>
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
>
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01

>
Is this the definition of the infinite set of H? We can think of many more simulations that only these.

>
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
>
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.

>
If H is a decider of any kind then the D build from it reaches its line
4 as numberd above. Whether the simulation of D by H reaches that line
is another question.
>

>
*My fully operational code proves otherwise*
>
I seems like you guys don't have a clue about how infinite
recursion works. You can run the code and see that I am correct.
>
I have one concrete instance as fully operational code.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
line 555 u32 HH(ptr P, ptr I) its input in on
line 932 int DD(int (*x)())

>
HH is completely broken - it uses a global variable which is allows HH to detect whether it is the outer HH or a nested (simulated) HH. As a result, the nested HH behaves completely differently to the outer HH - I mean /completely/ differently: it goes through a totally separate "I am called in nested mode" code path!
>

>
The encoding of HH is not the pure function that it needs to be to
be a computable function.
>
*Maybe you can settle this*
>
The disagreement is entirely over an enormously much simpler thing.
The disagreement is that Richard says that a D simulated by H could
reach past its own line 03 and halt.

>
Here's the proof:
>
1. A simulation always produces an identical execution trace to the direct execution.

>
*When pathological self-reference is involved this is counter-factual*
That no one can possibly show the steps of how D simulated by H possibly
reach line 06 of H proves this.

>
>
>

>
Richard tried to get away with D never simulated by H as an example
of D simulated by H:

>
Nope, you are looking at the WRONG message, and I have told you this multiple times.

>
Message-ID: <v0ummt$2qov3$2@i2pn2.org>
*When you interpret*
On 5/1/2024 7:28 PM, Richard Damon wrote:
 > On 5/1/24 11:51 AM, olcott wrote:
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
as *D NEVER simulated by H*
>
you have shown a reckless disregard for the truth
that would win a defamation case.
>

 My H simulated 0 steps of D, of which was ALL of the steps it simulated correctly.

*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer