XPost: sci.logic

On 7/9/24 7:49 PM, olcott wrote:

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Nope, you have a problem with your definitons

If HHH "correctly" emulatates only a finite number of steps, and then
stops, it did NOT ACTUALLY CORRECTLY emulate the input, as one part of
the definition of all the instructions it saw was that the next
instruction in sequence WILL be run.

Thus, an only PARTIAL emulation does not reveal the full behaior of the
input, and says nothing about what happens in the behavior of the input
after that point.

If that is what HHH does, as you claims make it clear is what actually
happens, then the actual CORRECT behavior of DDD (that was partially
emulated by HHH) will see that HHH return to it (but HHH will not see
that happen) and thus it will return.

Yes, if your HHH actually does a COMPLETE correct emulation as you
statement above seems to say, then DDD will not return, but HHH will
never answer, and thus never reported on the behavior (as pure functions
can only report by their return value)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-09 23:49:16 +0000, olcott said:

_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]

The subject line is misleading. There is only one DDD so "DDD correctly emulated by HHH" should simply mean DDD and nothing else. But apparently
the author intends to mean that HHH cannot fully emulate DDD.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 7/9/24 11:08 PM, olcott wrote:

On 7/9/2024 9:51 PM, Richard Damon wrote:

On 7/9/24 7:49 PM, olcott wrote:

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Nope, you have a problem with your definitons

No the problem is your ADD has again caused
you to not pay close enough attention. The
above version has always been airtight since
the first time that I wrote it.

As a submarine with a screen door.

You are just proving you don't know what you are talking about.

The emulation of DDD by HHH can't make it there, but the DDD that was
emulated only a finite number of steps by HHH will, after the HHH aborts
its emulation and returns to its caller (which was DDD).

You just don't understand the difference between Reality and the
observation of it, which is why you confuse Truth with Knowledge.

Any HHH that only emulates a finite number of instructions and then
stops does NOT do a fully correct emulation, since every instruction it emulated includes the property that the next instruction WILL run, and
thus needs to be emulated, and thus doesn't get to see the full behavior
of the input.

The part it misses is the difference.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

This is a multi-part message in MIME format.
On 7/10/2024 6:24 AM, Richard Damon wrote:

On 7/9/24 11:08 PM, olcott wrote:

On 7/9/2024 9:51 PM, Richard Damon wrote:

On 7/9/24 7:49 PM, olcott wrote:

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Nope, you have a problem with your definitons

No the problem is your ADD has again caused
you to not pay close enough attention. The
above version has always been airtight since
the first time that I wrote it.

As a submarine with a screen door.

You are just proving you don't know what you are talking about.

The emulation of DDD by HHH can't make it there, but the DDD that was emulated only a finite number of steps by HHH will, after the HHH
aborts its emulation and returns to its caller (which was DDD).

We are only talking about DDD correctly emulated by DDD,
your ADD forced you to keep forgetting that. I put in
key details making this airtight:

*DDD correctly emulated by any pure function HHH
that correctly emulates 1 to ∞ steps of DDD can't
make it past the above line of code no matter what.
*

You just don't understand the difference between Reality and the
observation of it, which is why you confuse Truth with Knowledge.

Any HHH that only emulates a finite number of instructions and then
stops does NOT do a fully correct emulation, since every instruction
it emulated includes the property that the next instruction WILL run,
and thus needs to be emulated, and thus doesn't get to see the full
behavior of the input.

The part it misses is the difference.

--
Copyright 2024 Olcott

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

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<div class="moz-cite-prefix">On 7/10/2024 6:24 AM, Richard Damon
wrote:<br>
</div>
<blockquote type="cite"
cite="mid:[email protected]">On
7/9/24 11:08 PM, olcott wrote:
<br>
<blockquote type="cite">On 7/9/2024 9:51 PM, Richard Damon wrote:
<br>
<blockquote type="cite">On 7/9/24 7:49 PM, olcott wrote:
<br>
<blockquote type="cite">
<br>
_DDD()
<br>
[00002163] 55         push ebp      ; housekeeping
<br>
[00002164] 8bec       mov ebp,esp   ; housekeeping
<br>
[00002166] 6863210000 push 00002163 ; push DDD
<br>
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
<br>
<br>
DDD correctly emulated by any pure function HHH that
<br>
correctly emulates 1 to ∞ steps of DDD can't make it
<br>
past the above line of code no matter what.
<br>
<br>
[00002170] 83c404     add esp,+04
<br>
[00002173] 5d         pop ebp
<br>
[00002174] c3         ret
<br>
Size in bytes:(0018) [00002174]
<br>
<br>
</blockquote>
<br>
Nope, you have a problem with your definitons
<br>
<br>
</blockquote>
<br>
No the problem is your ADD has again caused
<br>
you to not pay close enough attention. The
<br>
above version has always been airtight since
<br>
the first time that I wrote it.
<br>
<br>
</blockquote>
<br>
As a submarine with a screen door.
<br>
<br>
You are just proving you don't know what you are talking about.
<br>
<br>
The emulation of DDD by HHH can't make it there, but the DDD that
was emulated only a finite number of steps by HHH will, after the
HHH aborts its emulation and returns to its caller (which was
DDD).
<br>
</blockquote>
<p><br>
</p>
<p>We are only talking about DDD correctly emulated by DDD,<br>
your ADD forced you to keep forgetting that. I put in<br>
key details making this airtight: <br>
</p>
<font size="6"><b>DDD correctly emulated by any pure function HHH <br>
that correctly emulates 1 to ∞ steps of DDD can't <br>
make it past the above line of code no matter what.<br>
</b></font>
<p></p>
<p><br>
</p>
<blockquote type="cite"
cite="mid:[email protected]">
<br>
You just don't understand the difference between Reality and the
observation of it, which is why you confuse Truth with Knowledge.
<br>
<br>
Any HHH that only emulates a finite number of instructions and
then stops does NOT do a fully correct emulation, since every
instruction it emulated includes the property that the next
instruction WILL run, and thus needs to be emulated, and thus
doesn't get to see the full behavior of the input.
<br>
<br>
The part it misses is the difference.
<br>
<br>
<br>
</blockquote>
<p><br>
</p>
<pre class="moz-signature" cols="72">--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer</pre>
</body>
</html>

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott:

On 7/9/2024 11:01 PM, joes wrote:

That means that HHH doesn't return, in particular that it doesn't
abort.

DDD correctly emulated by any pure function HHH that correctly emulates
1 to ∞ steps of DDD can't make it past the above line of code no matter what.

That line being the call to itself -> it can't simulate itself.

*DDD NEVER HALTS*

DDD ONLY calls HHH...

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott:

On 7/9/2024 11:01 PM, joes wrote:
  > That means that HHH doesn't return, in particular that it doesn't
  > abort.
DDD correctly emulated by any pure function HHH that correctly emulates
1 to ∞ steps of DDD can't make it past the above line of code no matter >>> what.

That line being the call to itself -> it can't simulate itself.

*DDD NEVER HALTS*

DDD ONLY calls HHH...

void DDD()
{
  HHH(DDD);
  return;
}

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

You mean the emulation by HHH never gets there which is something different.

The first is behavior in the real world of the programs.

The second is the observation of that behavion by HHH.

HHH only gets partial information before it stops its observation, and
thus doesn't actually know the right answer.

You just don't understand the difference between truth and knowledge,
which means you don't understand what truth actually is.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott:

On 7/9/2024 11:01 PM, joes wrote:
  > That means that HHH doesn't return, in particular that it >>>>>>>>> doesn't
  > abort.
DDD correctly emulated by any pure function HHH that correctly >>>>>>>>> emulates
1 to ∞ steps of DDD can't make it past the above line of code >>>>>>>>> no matter
what.

That line being the call to itself -> it can't simulate itself. >>>>>>>>

*DDD NEVER HALTS*

DDD ONLY calls HHH...

void DDD()
{
   HHH(DDD);
   return;
}

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

You have a dead cat in your driveway does not mean that
you have a peanut butter sandwich on your front porch.
It has taken you at least 1000 messages to see that.

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

WRONG, you don't seem to understand the difference between DDD and
HHH's emualtion of it.

Would you bet your immortal soul that DDD simulated
by HHH (as provided above) would terminate normally?

That is a ambiguous statement, showing your attempt at deciet.

We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.

And thus you stipulate that you are a LIAR.

By the semantic of the x86 programming language, the only correct
simulation is a FULL simulation that proceeds to the final insttuction
as that is what the x86 language defines, and thus NO HHH can correct
simulate less than an infinite number of instructions of the program
DDD, and in doing so spends virtually all of its time emulationg the instructions of HHH, showing that it will never halt.

When you admit to HHH not being actually a correct emulator and let it
abort, and return, we can then establish that a DDD that calls such a
PARTIAL emulator HHH will be finite and return even though the PARTAL
emulation by that HHH mever sees it because it stops too soon,

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Will you bet your immortal soul that any of the above
DDD of DDD/HHH pairs reach their own machine address
of 00002174 and halt?

Sure, because it is clearly true that EVERY DDD that calls an HHH(DDD)
that returns will get to that final return, even though its HHH will
never simulate its copy of it to that point, because it aborts its
PARTIAL simulation and lies to itself about what it is doing (or more accurately, YOU LIED TO YOURSELF about the behavior of HHH and claimed a falsehood) and thus gets the wrong andwer.

Claiming ambiguity without specifically pointing this
out will be construed as deception thus swearing your
allegiance to the father of lies.

But you have already made that pledge, so yI guess you are just lost.

No ambiguity about that claim, DDD definitly gets to the return when run
if HHH(DDD) returns.

The ambiguity comes up when you use wording that half implies you are
looking at the (partial) simulation but also implies you are looking at
the actual behavior.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-10 13:25:54 +0000, olcott said:

On 7/10/2024 2:02 AM, Mikko wrote:

On 2024-07-09 23:49:16 +0000, olcott said:

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

The subject line is misleading. There is only one DDD so "DDD correctly
emulated by HHH" should simply mean DDD and nothing else.

*I added this to my latest paper*

That doesn't fix the subject line.

Every time any HHH correctly emulates DDD it calls the
x86utm operating system to create a separate process
context with its own memory virtual registers and stack,
thus each recursively emulated DDD is a different instance.

There should be a comma after the word "memory".

Simulating Termination Analyzer H is Not Fooled by Pathological Input D https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

There is another error on the first page. The first sentence says: "The notion of a simulating termination analyzer is examined at the concrete level of pairs of C functions". That is contracited in the fourth paragraph: "To understand this analysis requires a sufficient knowledge of the C programming language
and what an x86 emulator does". The analysis is not at the level of C functions if any knowledge about an x86 emulator is needed.


--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott:

On 7/9/2024 11:01 PM, joes wrote:
  > That means that HHH doesn't return, in particular that it >>>>>>>>>>> doesn't
  > abort.
DDD correctly emulated by any pure function HHH that
correctly emulates
1 to ∞ steps of DDD can't make it past the above line of code >>>>>>>>>>> no matter
what.

That line being the call to itself -> it can't simulate itself. >>>>>>>>>>

*DDD NEVER HALTS*

DDD ONLY calls HHH...

void DDD()
{
   HHH(DDD);
   return;
}

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

You have a dead cat in your driveway does not mean that
you have a peanut butter sandwich on your front porch.
It has taken you at least 1000 messages to see that.

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

WRONG, you don't seem to understand the difference between DDD and >>>>>> HHH's emualtion of it.

Would you bet your immortal soul that DDD simulated
by HHH (as provided above) would terminate normally?

That is a ambiguous statement, showing your attempt at deciet.

We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.

And thus you stipulate that you are a LIAR.

By the semantic of the x86 programming language, the only correct
simulation is a FULL simulation

In other words you are trying to get away with the lie that
when 1 step of DDD is correctly emulated that 0 steps of DDD
are correctly emulated.

Repent of this lie or risk damnation.

WHAT LIE?

That x86 defines that every instruction DDD/HHH that gets emulatiod
included the definition that the next instruction WILL run?

That is just truth.

Calling the truth a lie is just more of your lies.

I think you have already damned yourself.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/11/24 10:28 PM, olcott wrote:

On 7/11/2024 9:08 PM, Richard Damon wrote:

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott:

On 7/9/2024 11:01 PM, joes wrote:
  > That means that HHH doesn't return, in particular that >>>>>>>>>>>>> it doesn't
  > abort.
DDD correctly emulated by any pure function HHH that >>>>>>>>>>>>> correctly emulates
1 to ∞ steps of DDD can't make it past the above line of >>>>>>>>>>>>> code no matter
what.

That line being the call to itself -> it can't simulate itself. >>>>>>>>>>>>

*DDD NEVER HALTS*

DDD ONLY calls HHH...

void DDD()
{
   HHH(DDD);
   return;
}

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

You have a dead cat in your driveway does not mean that
you have a peanut butter sandwich on your front porch.
It has taken you at least 1000 messages to see that.

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

WRONG, you don't seem to understand the difference between DDD >>>>>>>> and HHH's emualtion of it.

Would you bet your immortal soul that DDD simulated
by HHH (as provided above) would terminate normally?

That is a ambiguous statement, showing your attempt at deciet.

We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.

And thus you stipulate that you are a LIAR.

By the semantic of the x86 programming language, the only correct
simulation is a FULL simulation

In other words you are trying to get away with the lie that
when 1 step of DDD is correctly emulated that 0 steps of DDD
are correctly emulated.

Repent of this lie or risk damnation.

WHAT LIE?

When 1,2,3... ∞ steps of DDD are correctly emulated by
HHH it is a lie to say that this many instructions were
not correctly emulated and you know it.

But only N instructions "correctly emulated" is NOT a CORRECT emulaition
of the instructions of DDD/HHH

WHERE in the Intel x86 documenation does it say that the processor might
just stop after one of the normal instructions.

They ALL have the definition that after they execute, then next one to
follow will also be executed.

You logic says that you can call a road as having infinite length by
riving on it one mile and then gett ing off it, since hta tshowed that
you didn't drive it to the end.

Remember, by the time that HHH can start to emulate the input, teh full
program has been determined by pairing it with that HHH, so if you talk
about "changing" HHH to something different, you can't change the copy
that DDD is calling, or you change the input and thus invalidate you claims.

You are just painting yourself into the corner with your lies.

This HHH, that aborts its simulation did NOT do a "Correct Emulation"
per the definition of the x86 processor, but only a PARTIAL emulation,
that BY DEFINITION doesn't define the behavior after the emulation stopped.

And the actual CORRECT emulation of that exact input shows that it will
emulate that code of HHH that aborts it emulation of it copy of DDD (in
a different process space) and returning to the DDD in its process space
and that DDD returning, thus showing that this HHH didn't actually need
to abort its emulation, as the HHH in the other process space will and
that makes the input halt.

You are just stuck with bad definitions that just show you to be an
igmorant liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-11 13:38:56 +0000, olcott said:

On 7/11/2024 1:42 AM, Mikko wrote:

On 2024-07-10 13:25:54 +0000, olcott said:

On 7/10/2024 2:02 AM, Mikko wrote:

On 2024-07-09 23:49:16 +0000, olcott said:

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

The subject line is misleading. There is only one DDD so "DDD correctly >>>> emulated by HHH" should simply mean DDD and nothing else.

*I added this to my latest paper*

That doesn't fix the subject line.

Then I don't understand what you are saying.

Perhaps you should ask someone who konws English better that you or I.

"DDD correctly emulated by HHH cannot possibly halt"
When halt means reaching its own final state and terminating normally.

Every time any HHH correctly emulates DDD it calls the
x86utm operating system to create a separate process
context with its own memory virtual registers and stack,
thus each recursively emulated DDD is a different instance.

There should be a comma after the word "memory".

Yes.

Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

There is another error on the first page. The first sentence says: "The
notion of a simulating termination analyzer is examined at the concrete
level of pairs of C functions". That is contracited in the fourth paragraph: >> "To understand this analysis requires a sufficient knowledge of the C
programming language and what an x86 emulator does". The analysis is not at >> the level of C functions if any knowledge about an x86 emulator is needed.

That is a good idea. The less prerequisite knowledge my target
audience needs the more people will be able understand what I am
saying. I am trying to make my first page as simple as possible.

To understand this analysis requires a sufficient knowledge
of the C programming language. An x86 emulator works just
like a C language interpreter except that it uses the compiled
machine language of a function instead of its source-code.

Perhapos you should say that an x86 emulator executes the compiled program
just like an x86 processor would but can in addition produce a trace of
the execution.

That HHH is built from an x86 emulator allows it to simulate
other C functions as if it was a C language interpreter.

The second page will have the more difficult prerequisites.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Thu, 11 Jul 2024 22:30:00 -0500 schrieb olcott:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

On 7/11/2024 9:08 PM, Richard Damon wrote:

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/9/2024 11:01 PM, joes wrote:

*DDD NEVER HALTS*

DDD ONLY calls HHH...

DDD correctly emulated by any pure function HHH that >>>>>>>>>>>>> correctly emulates 1 to ∞ lines of DDD can't make it to the >>>>>>>>>>>>> second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

DDD correctly emulated by any pure function HHH that correctly >>>>>>>>>>> emulates 1 to ∞ lines of DDD can't make it to the second line >>>>>>>>>>> of DDD no matter what.

WRONG, you don't seem to understand the difference between DDD >>>>>>>>>> and HHH's emualtion of it.

We stipulate that the only measure of a correct emulation is the >>>>>>> semantics of the x86 programming language. By this measure when 1 >>>>>>> to ∞ steps of DDD are correctly emulated by each pure function x86 >>>>>>> emulator HHH (of the infinite set of every HHH that can possibly >>>>>>> exist) then DDD cannot possibly reach its own machine address of >>>>>>> 00002174 and halt.

By the semantic of the x86 programming language, the only correct
simulation is a FULL simulation

In other words you are trying to get away with the lie that when 1
step of DDD is correctly emulated that 0 steps of DDD are correctly
emulated.

When 1,2,3... ∞ steps of DDD are correctly emulated by HHH it is a lie >>> to say that this many instructions were not correctly emulated and you
know it.

But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH

I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!

Please don't insult ADD people.
You did talk of an HHH that only simulated a fixed number of steps.
They do not provide a correct (full) simulation.
The only interesting case is infinitely many steps of a nonterminating
input.

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 12.jul.2024 om 14:08 schreef olcott:

On 7/12/2024 3:05 AM, joes wrote:

Am Thu, 11 Jul 2024 22:30:00 -0500 schrieb olcott:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

On 7/11/2024 9:08 PM, Richard Damon wrote:

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/9/2024 11:01 PM, joes wrote:

*DDD NEVER HALTS*

DDD ONLY calls HHH...

DDD correctly emulated by any pure function HHH that >>>>>>>>>>>>>>> correctly emulates 1 to ∞ lines of DDD can't make it to the >>>>>>>>>>>>>>> second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

DDD correctly emulated by any pure function HHH that correctly >>>>>>>>>>>>> emulates 1 to ∞ lines of DDD can't make it to the second line >>>>>>>>>>>>> of DDD no matter what.

WRONG, you don't seem to understand the difference between DDD >>>>>>>>>>>> and HHH's emualtion of it.

We stipulate that the only measure of a correct emulation is the >>>>>>>>> semantics of the x86 programming language. By this measure when 1 >>>>>>>>> to ∞ steps of DDD are correctly emulated by each pure function x86 >>>>>>>>> emulator HHH (of the infinite set of every HHH that can possibly >>>>>>>>> exist) then DDD cannot possibly reach its own machine address of >>>>>>>>> 00002174 and halt.

By the semantic of the x86 programming language, the only correct >>>>>>>> simulation is a FULL simulation

In other words you are trying to get away with the lie that when 1 >>>>>>> step of DDD is correctly emulated that 0 steps of DDD are correctly >>>>>>> emulated.

When 1,2,3... ∞ steps of DDD are correctly emulated by HHH it is a lie >>>>> to say that this many instructions were not correctly emulated and you >>>>> know it.

But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH

I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!

Please don't insult ADD people.

This does not say from 1 to 8 steps
when 1 to ∞ steps of DDD are correctly emulated

When I say the same words 150 and Richard does not
see these words I have to know why this is.
My aim is effective communication. I can't fix
the issue unless I know what the issue it.

The two possibilities Richard's ADD, and Richard
is a Liar. If is is Richards's ADD then repeating
the same sentence a dozen times seems to help.

If Richard is being a liar then calling him a Liar
and telling him where this leads seems to help.

You did talk of an HHH that only simulated a fixed number of steps.
They do not provide a correct (full) simulation.

when 1 to ∞ steps of DDD are correctly emulated in
the infinite set of every HHH/DDD pair and no DDD
halts then we can say that DDD DOES NOT HALT.

If 1 to ∞ steps are simulated by HHH and none of these simulations is correct, then none of the simulations is correct.
If N cycles are simulated by HHH when N+1 cycles must be simulated to
make the simulation correct, then the simulation is incorrect for N = 1
to ∞ (meaning in the limit of arbitrarily large N).
So, you definitely proved that none of the HHH can possible simulate
itself correctly.
Every DDD in this set halts, but none of the simulations of HHH by
itself in this set is able to show the halting, because the simulation
is always aborted one cycle too soon and therefore, the simulation
misses the last cycle, the abort and the return. So, the simulation does
not show the full behaviour of the input.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 12.jul.2024 om 14:28 schreef olcott:

On 7/12/2024 6:15 AM, Richard Damon wrote:

On 7/11/24 11:30 PM, olcott wrote:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.

Which proves that the simulation is incorrect.
A correct simulation is able to reach the end of a halting program.
To make a simulation correct and follow the semantics of the x86
language, it is incorrect to abort halfway a halting program.
So, your conclusion is not inline with the stipulation to use the
semantics of the 86 language as a measure of a correct simulation.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

When 1,2,3... ∞ steps of DDD are correctly emulated by
HHH it is a lie to say that this many instructions were
not correctly emulated and you know it.

But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH

I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!

So, I guess NONE of them ever stop before reaching the end, if none of
them stop before that.

1,2,3... ∞ steps of DDD are correctly emulated is every
HHH/DDD pair that can possibly exist when HHH is a pure
function x86 emulator.

When N steps (with N = 1,2,3, up to ∞ , meaning up to an arbitrary large number) are simulated and none of these simulations is correct, because
they all abort one cycle too soon, then the conclusion must be that HHH
cannot possibly simulate itself correctly up to the end. None of them is
able to use the semantics of the X86 language correctly, because that
semantics does not require an abort for a halting program.
(We see that other simulators can simulate HHH up to the end, but HHH
cannot simulate *itself* up to the end.)
This is definitely not a problem of DDD, but of HHH, because without
DDD, such as in:

int main()
{
return HHH(main);
}

We see the same problem.

The problem is that HHH is unable to see the difference between a finite
and an infinite recursion.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

HHH decides that any recursion with more than two cycles is an infinite recursion.
But two cycles are not the same as an infinite number of cycles.

Sipser would agree that a simulation that aborts halfway its simulation
is incorrect.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Fri, 12 Jul 2024 07:28:56 -0500 schrieb olcott:

On 7/12/2024 6:15 AM, Richard Damon wrote:

On 7/11/24 11:30 PM, olcott wrote:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language. By this measure when 1 to ∞ steps of DDD are correctly emulated by each pure function x86 emulator
HHH (of the infinite set of every HHH that can possibly exist) then DDD cannot possibly reach its own machine address of 00002174 and halt.

We are only interested in a simulator that simulates ALL steps.

When 1,2,3... ∞ steps of DDD are correctly emulated by HHH it is a >>>>> lie to say that this many instructions were not correctly emulated
and you know it.

But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH

I didn't limit it to N. I say 1 to infinity steps!

That IS a limit.

So, I guess NONE of them ever stop before reaching the end, if none of
them stop before that.

1,2,3... ∞ steps of DDD are correctly emulated is every HHH/DDD pair
that can possibly exist when HHH is a pure function x86 emulator.

Only the unlimited case matters.

No more dishonest shell game ruse

I still haven't understood what you think we are switching between.

That wastes weeks and weeks talking in circles.

It's rather your very low signal to noise ratio.

For each element of this infinite set of HHH/DDD pairs DDD never halts.
For every finite N number of emulated steps HHH halts.

How can a simulation of a nonterminating program halt?

This means that every HHH of this set that aborts its emulation of DDD
is correct to reject its DDD as non halting.

A simulator cannot abort.

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 12.jul.2024 om 16:51 schreef olcott:

On 7/12/2024 8:02 AM, Fred. Zwarts wrote:

Op 12.jul.2024 om 14:08 schreef olcott:

when 1 to ∞ steps of DDD are correctly emulated in
the infinite set of every HHH/DDD pair and no DDD
halts then we can say that DDD DOES NOT HALT.

If 1 to ∞ steps are simulated by HHH and none of these simulations is
correct, then none of the simulations is correct.

*Vacuous "truth" is a form of deception*

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

But only those steps are simulated correctly. The steps that are skipped
are not considered. So the simulation as a whole is incorrect.
Simulating only N steps of a program of N+1 steps makes the simulation incorrect, because it does not show the full behaviour, of the last step
and the end of the program. The simulation does not process the full
input that it is given.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.

But the simulation of further steps is skipped, making the simulation as
a whole incorrect, because it does not show the full behaviour.

HHH₂ two steps of DDD are correctly emulated by HHH.

But the simulation of further steps is skipped, making the simulation as
a whole incorrect, because it does not show the full behaviour.

HHH₃ three steps of DDD are correctly emulated by HHH.

But the simulation of further steps is skipped, making the simulation as
a whole incorrect, because it does not show the full behaviour.

...
HHH∞ The emulation of DDD by HHH never stops running.

Which is also not a correct simulation, because it does not end.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

and where the last step is skipped, which makes the whole simulation
incorrect. So none of the instances of HHH in this set was able to do a
correct simulation.

No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.

Showing that the simulation of all instances is incorrect.

Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.

No. None of these simulations is correct. Each HHH that aborts is shown
to abort 1 step before the simulated HHH would reach its end. So, the
abort was always premature and no conclusion about halting or
non-halting is possible. For each of the HHH that abort, it makes no
sense to dream of a HHH that does not abort, because that is not the one
that this HHH is simulating.
Each of the HHH in this set only simulates itself, not another one of
this set. Dreaming of another HHH in this set when simulating only
itself, is irrelevant and does not make the simulation correct.

No matter how much you want to be it correct, or how many times you
repeat that its is correct, it does not change the fact that none of
these simulations is incorrect, because none of them is able to reach
the end.
For each HHH in this set we see that HHH cannot possibly simulate itself correctly.

DDD has nothing to do with it. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which is required to halt, but it decides that HHH does not
halt.

HHH is unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.
When it should decide about Finite_Recursion(5), the programmer starts
to dream about an infinite set of Finite_Recursion(M), with M=0 to
infinity, and decides that it must be an infinite recursion.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/12/24 8:08 AM, olcott wrote:

On 7/12/2024 3:05 AM, joes wrote:

Am Thu, 11 Jul 2024 22:30:00 -0500 schrieb olcott:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

On 7/11/2024 9:08 PM, Richard Damon wrote:

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/9/2024 11:01 PM, joes wrote:

*DDD NEVER HALTS*

DDD ONLY calls HHH...

DDD correctly emulated by any pure function HHH that >>>>>>>>>>>>>>> correctly emulates 1 to ∞ lines of DDD can't make it to the >>>>>>>>>>>>>>> second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

DDD correctly emulated by any pure function HHH that correctly >>>>>>>>>>>>> emulates 1 to ∞ lines of DDD can't make it to the second line >>>>>>>>>>>>> of DDD no matter what.

WRONG, you don't seem to understand the difference between DDD >>>>>>>>>>>> and HHH's emualtion of it.

We stipulate that the only measure of a correct emulation is the >>>>>>>>> semantics of the x86 programming language. By this measure when 1 >>>>>>>>> to ∞ steps of DDD are correctly emulated by each pure function x86 >>>>>>>>> emulator HHH (of the infinite set of every HHH that can possibly >>>>>>>>> exist) then DDD cannot possibly reach its own machine address of >>>>>>>>> 00002174 and halt.

By the semantic of the x86 programming language, the only correct >>>>>>>> simulation is a FULL simulation

In other words you are trying to get away with the lie that when 1 >>>>>>> step of DDD is correctly emulated that 0 steps of DDD are correctly >>>>>>> emulated.

When 1,2,3... ∞ steps of DDD are correctly emulated by HHH it is a lie >>>>> to say that this many instructions were not correctly emulated and you >>>>> know it.

But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH

I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!

Please don't insult ADD people.

This does not say from 1 to 8 steps
when 1 to ∞ steps of DDD are correctly emulated

Which, the way you are now describing it, only happens for the HHH that
never aborts.

But, for you claims, you ALSO mean that 1 to ∞ steps also includes all
the HHH that only do a finite number of steps and then abort.

Thus, you are trying to lie by the method of changing meaning.

When I say the same words 150 and Richard does not
see these words I have to know why this is.
My aim is effective communication. I can't fix
the issue unless I know what the issue it.

No, when you try to use the same words with two different meanings you
are just lying.

The two possibilities Richard's ADD, and Richard
is a Liar. If is is Richards's ADD then repeating
the same sentence a dozen times seems to help.

No, Peter Olcott is just a liar by using double-speak, truying to have
his words mean two different things at the same time.

If Richard is being a liar then calling him a Liar
and telling him where this leads seems to help.

But since I am not lying, but just pointing out YOUR lies, you are just furthering you own lies.

You did talk of an HHH that only simulated a fixed number of steps.
They do not provide a correct (full) simulation.

when 1 to ∞ steps of DDD are correctly emulated in
the infinite set of every HHH/DDD pair and no DDD
halts then we can say that DDD DOES NOT HALT.

And by saying "NO DDD", that shows that you actually means the DDD that
are simulated for just 1 step, for just 2 steps, for just 3 steps, and
so on, which means you claim that you only meant the infinte number of
steps is just a LIE. and that

Several dishonest reviewers tried to use the https://jorynjenkins.com/hiding-the-pea/
shell game ruse to avoid talking about the HHH/DDD
pair that I was talking about for weeks and weeks.

No YOU are plying the shell game by changing the meaning of you words
sometimes even mid-sentence.

WHICH HHH/DDD pair are you ACTUALLY talking about?

The one HHH with its DDD that you claim main calls and gets the
"correct" answer (that is actually wrong). That ONE HHH being the one in
your code repositiory.

The ine HHH with its DDD that never aborts, and thus never answers, and
is the ONLY DDD that never returns.

One of the "infinite set" of HHH/DDD pairs that emulates the input for
only a finite number of steps, and then claim that since then they
haven't reached the final state, and that OTHER HHH (the one that
doesn't abort) showed that ITS DDD (the one based on the OTHER HHH, that doesn't abort) would never halt, that it can claim that ITS DDD (which
is different from the above, since it is paired to a different HHH, one
that does abort) would act the same.

NONE of those HHH ever correctly answer about the DDD that they were
given (that has been pair to THEM).

And all you arguments are just lies trying to play the shell game.

You will find out soon enough about the results of your life of lies.

To counter this I started talking about every element
of the infinite set of HHH/DDD pairs that can possibly
exist. That is what I am doing now.

The only interesting case is infinitely many steps of a nonterminating
input.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-12 14:51:05 +0000, olcott said:

On 7/12/2024 8:02 AM, Fred. Zwarts wrote:

Op 12.jul.2024 om 14:08 schreef olcott:

when 1 to ∞ steps of DDD are correctly emulated in
the infinite set of every HHH/DDD pair and no DDD
halts then we can say that DDD DOES NOT HALT.

If 1 to ∞ steps are simulated by HHH and none of these simulations is
correct, then none of the simulations is correct.

*Vacuous "truth" is a form of deception*

No, it is not. A vacuous truth is a truth. No truth is a deception.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Fri, 12 Jul 2024 07:08:04 -0500 schrieb olcott:

On 7/12/2024 3:05 AM, joes wrote:

Am Thu, 11 Jul 2024 22:30:00 -0500 schrieb olcott:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

On 7/11/2024 9:08 PM, Richard Damon wrote:

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/9/2024 11:01 PM, joes wrote:

*DDD NEVER HALTS*

DDD ONLY calls HHH...

DDD correctly emulated by any pure function HHH that >>>>>>>>>>>>>>> correctly emulates 1 to ∞ lines of DDD can't make it to >>>>>>>>>>>>>>> the second line of DDD no matter what.

Nope, DDD does if HHH(DDD) returns.

DDD correctly emulated by any pure function HHH that >>>>>>>>>>>>> correctly emulates 1 to ∞ lines of DDD can't make it to the >>>>>>>>>>>>> second line of DDD no matter what.

WRONG, you don't seem to understand the difference between >>>>>>>>>>>> DDD and HHH's emualtion of it.

We stipulate that the only measure of a correct emulation is the >>>>>>>>> semantics of the x86 programming language. By this measure when >>>>>>>>> 1 to ∞ steps of DDD are correctly emulated by each pure function >>>>>>>>> x86 emulator HHH (of the infinite set of every HHH that can
possibly exist) then DDD cannot possibly reach its own machine >>>>>>>>> address of 00002174 and halt.

By the semantic of the x86 programming language, the only correct >>>>>>>> simulation is a FULL simulation

In other words you are trying to get away with the lie that when 1 >>>>>>> step of DDD is correctly emulated that 0 steps of DDD are
correctly emulated.

When 1,2,3... ∞ steps of DDD are correctly emulated by HHH it is a >>>>> lie to say that this many instructions were not correctly emulated
and you know it.

But only N instructions "correctly emulated" is NOT a CORRECT
emulaition of the instructions of DDD/HHH

I didn't limit it to N. Is this your ADD? I say 1 to infinity steps!

Please don't insult ADD people.

When I say the same words 150 and Richard does not see these words I
have to know why this is.
My aim is effective communication. I can't fix the issue unless I know
what the issue it.

You communicate very ineffectively. You should listen to others and
respond to their questions.

The two possibilities Richard's ADD, and Richard is a Liar. If is is Richards's ADD then repeating the same sentence a dozen times seems to
help.

3. Richard is annoying but right, and you are a delusional spammer who
can't rephrase.

You did talk of an HHH that only simulated a fixed number of steps.
They do not provide a correct (full) simulation.

when 1 to ∞ steps of DDD are correctly emulated in the infinite set of every HHH/DDD pair and no DDD halts then we can say that DDD DOES NOT
HALT.

DDD halts if HHH does, period. And HHH shall be a decider.

Several dishonest reviewers tried to use the
shell game ruse to avoid talking about the HHH/DDD pair that I was
talking about for weeks and weeks.

What do you think the shells are?

To counter this I started talking about every element of the infinite
set of HHH/DDD pairs that can possibly exist.

Nobody is interested in an incomplete simulator.

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/13/24 7:12 PM, olcott wrote:

On 7/13/2024 6:00 PM, joes wrote:

Am Fri, 12 Jul 2024 07:08:04 -0500 schrieb olcott:

When I say the same words 150 and Richard does not see these words I
have to know why this is.
My aim is effective communication. I can't fix the issue unless I know
what the issue it.

You communicate very ineffectively. You should listen to others and
respond to their questions.

The two possibilities Richard's ADD, and Richard is a Liar. If is is
Richards's ADD then repeating the same sentence a dozen times seems to
help.

3. Richard is annoying but right, and you are a delusional spammer who
can't rephrase.

You did talk of an HHH that only simulated a fixed number of steps.
They do not provide a correct (full) simulation.

when 1 to ∞ steps of DDD are correctly emulated in the infinite set of >>> every HHH/DDD pair and no DDD halts then we can say that DDD DOES NOT
HALT.

DDD halts if HHH does, period. And HHH shall be a decider.

The DDD correctly emulated by HHH it its own separate
process context cannot possibly halt even though it
can be forced to stop running.

No, ALL DDDs that call an HHH that aborts its emulation and return will
return.

The emulation of DDD may not reach a final state, but the program it
represents do.

Note, "Emulations" do not actually exist in ANY actual process context,
just a virtual context in the emulator, and doesn't actually have
behavior only reveals the behavior of the machine emulated to the degree
that it is emulated.

Remember, "Process Context" is what you RUN programs in.

EmulaEmulationr have there own Process COntext that the emulator runs
in, and it creates within it a virtual contret to do the emulations in.
That is NOT a context setup by the "os".

Any input that must be aborted to prevent the non
termination of HHH necessarily specifies non-halting
behavior or it would never need to be aborted.

But it doesn't need to be aborts, as shown by the giving the input (that
is still paired to this HHH) to a fully corrected emulator that doesn't
abort its emulation, which will see DDD call that HHH and that HHH
deciding to abort and return to DDD which will return. And thus HHH did
not NEED to abort its emulaiton of DDD (though it did) because the
correct emulaition of that DDD will halt.

You are confusing it with a DIFFERENT DDD that calls the HHH that never
aborts, this DDD is not that one.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)