Is Richard a Liar?

On 5/10/24 7:39 PM, olcott wrote:

On 5/10/2024 5:39 PM, Richard Damon wrote:

On 5/10/24 6:28 PM, olcott wrote:

On 5/10/2024 4:59 PM, Richard Damon wrote:

On 5/10/24 5:43 PM, olcott wrote:

On 5/10/2024 4:19 PM, Richard Damon wrote:

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

On 5/10/2024 3:50 PM, Richard Damon wrote:

On 5/10/24 4:27 PM, olcott wrote:

On 5/10/2024 3:09 PM, Richard Damon wrote:

On 5/10/24 1:49 PM, olcott wrote:

On 5/10/2024 11:12 AM, Richard Damon wrote:

On 5/10/24 11:50 AM, olcott wrote:

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*

>
You haven't GIVEN a defined SPEC.
>
The only definition within Computation Theory, which is the space you started in, and claim to get to, doesn't have "aborted" simulations, so you don't have a defintion of what simulatioin actually means, other than doing something that tells you something about the behavior of what is simulated.
>
My H does that, by aborting its "simulation" in shows that THIS H did not simulate its input to a final state.
>
Just the same result that you partial set of H's showed.
>

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

>
Right, and simulating zero steps correctly and them aborting means H

>
*cannot possibly stop running unless aborted is not met*

>
Aborted after 0 steps which is all that that H does.
>

>
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*

>

>
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
>
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
>
*cannot possibly stop running unless aborted is not met*
*BY cannot possibly start running*
>

>
You can start and then immediately stop an not make any progress.
>
A bit like your "first point after 0".
>
You just don't understand how logic works.
>
And your definition is also illogical, as H either DOES or DOES NOT abort its simulation.
>

>
*WRONG DICHOTOMY STRAW-MAN DECEPTION*

>
But there is no Dichotomy, as there is just H, an not something to compare it to.
>
The other thing you compare it to is not H.
>

"...cannot possibly stop running unless aborted"
*stops running if not aborted or keeps running if not aborted*

>
But *THE* H does one or the other.
>

>
Is your employer aware that your memory is this bad?
Are you in management where slick double-talk can hide this?

>
Well, since you don't have an employer, I guess we can tell who performs better.
>

>
*I have repeated time and again that I have always been referring*
*to the specific infinite set of H/D pairs specified below*

>
And how does MAIN call an "Infinite set" of functions?
>
And how is that an exact implementation of the Linz Proof, were H and H^ are specific (but arbitrary) machines?
>

>
A "specific" and "arbitrary" machine is like a
very tiny little enormously huge thing.
>
We can have specific elements of an infinite set such
that every element of this set has common properties.

>
But the element is different then the set.
>

>
One element of any type of set theory set is different
THAN (not then) the whole set, WELL DUH !!!

 Right, so why do you lie that H is the SET, and not one element at a time.
 

>
Every element of natural numbers > 5 shares that common
property of > 5.
>

Right, but the set of natural numbers n > 5 doesn't have the property that the SET (as a set) is greater than 5, since that property is not a property of the set.
 Just like HALTING is a property of Program, not "sets of programs" so your POOP is just illogical.
 

*Richard can get this and lies about it*
*Richard can get this and lies about it*
*Richard can get this and lies about it*
*Richard can get this and lies about it*
>
Every D simulated by H shares the property that it is
simulated by H.

 Nope, because "being simulated by" is not a property of the machine iteself, but of the decider looking at it.
 

>
Every D NEVER simulated by H forms a set that is disjoint
from the above set.
>

 But simulating zero steps correctly *IS* simulating ALL steps simulated correctly if you stop before getting to step 1.
 You just don't understand the nature of universal qualifiers.
 Or the actual general meaning of "simulation"