Op 02.aug.2024 om 04:09 schreef olcott:

*This algorithm is used by all the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

No problem to agree with that. The only problem is that no correct
simulation has been shown. So this does not help you.

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

Indeed, until it deviates from the semantics of the x86 language.

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

No, HHH thinks that two recursions is enough to decide that there is an infinite recursion, It fails to see that one cycle later the simulation
would halt without abort.
So, the abort is premature. It skips the last few instructions of the
program, hiding in this way that the simulation would halt.
In other words, HHH cannot possibly simulate itself correctly.

Olcott really, really wants it to be correct, but he has no evidence for
it, but he thinks that ignoring the errors that have been pointed out
helps. He also thinks that repeating many times without evidence that it
is correct will make it correct.
He keeps dreaming that the HHH that does not halt, plays a role in the simulation of a HHH that aborts and halts.
But dreams are no substitute for fact, nor for logic.

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

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

--
Mikko

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

Op 03.aug.2024 om 15:48 schreef olcott:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
 by HHH cannot possibly reach its own return instruction?]

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

When it cannot possibly reach its own return instruction, it is an
incorrect simulation, no matter how often you repeat the word 'correct'.
It does not help to repeat the same error hundreds of times, without any evidence.
It is clear that HHH that aborts also halts, so when the simulation of
such a halting function cannot reach its return, the simulation fails.
It halts too soon. One cycle before the simulated HHH would abort and
halt. Skipping the last few instructions makes the simulation incorrect.
DDD is a misleading and unneeded complication. 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 halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

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

Op 03.aug.2024 om 16:20 schreef olcott:

On 8/3/2024 9:01 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:48 schreef olcott:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>      If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would never >>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

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

When it cannot possibly reach its own return instruction,

You are not allowed to disagree with the semantics of C
or the semantics of the x86 language. As long as the
execution trace is consistent with these then it is defined
to be correct.

Talking nonsense does not hide you problem. I don't disagree with that semantics.
It is HHH that deviates from the semantics of the x86 language by
skipping the last few instructions of a halting program, changing its
behaviour in this way.
Skipping instructions of a halting program makes the simulation incorrect.
You may dream of a HHH that does not abort and does not halt, but it
does not change the fact that a HHH that *does* abort and halt, when
correctly simulated, *does* abort and halt.
When HHH aborts itself, the simulated HHH (that aborts and halts) is
only one cycle for its abort and return.
But HHH cannot possibly simulate itself correctly.
Dreams are no substitute for fact, not for logic.

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

Op 03.aug.2024 om 17:01 schreef olcott:

On 8/3/2024 9:54 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 16:20 schreef olcott:

On 8/3/2024 9:01 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:48 schreef olcott:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>      until H correctly determines that its simulated D would never >>>>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>> not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

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

When it cannot possibly reach its own return instruction,

You are not allowed to disagree with the semantics of C
or the semantics of the x86 language. As long as the
execution trace is consistent with these then it is defined
to be correct.

Talking nonsense does not hide you problem. I don't disagree with that
semantics.
It is HHH that deviates from the semantics of the x86 language by
skipping the last few instructions of a halting program, changing its
behaviour in this way.

There are no last few instructions of any halting program
that DDD correctly emulated by HHH skips.

Why substituting facts by dreams?
DDD halts when HHH halts. HHH skips tte last cycle of the simulated
HHH,after which it would return to DDD, which would then return too.

Within the semantics of C and the semantics of the x86
language (thus specifying a correct simulation) the call
to HHH(DDD) from the simulated DDD cannot possibly return.

Indeed, that is why it is incorrect. A correct simulation does return,
as is shown by the simulation of HHH by HHH1.
It is sad that all evidence you show, prove the opposite of your claims.

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

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

--
Mikko

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

On 8/4/24 8:30 AM, olcott wrote:

On 8/4/2024 1:11 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:01 schreef olcott:

On 8/3/2024 9:54 AM, Fred. Zwarts wrote:>>>

Talking nonsense does not hide you problem. I don't disagree with
that semantics.
It is HHH that deviates from the semantics of the x86 language by
skipping the last few instructions of a halting program, changing
its behaviour in this way.

There are no last few instructions of any halting program
that DDD correctly emulated by HHH skips.

Why substituting facts by dreams?
DDD halts when HHH halts. HHH skips tte last cycle of the simulated
HHH,after which it would return to DDD, which would then return too.

Within the semantics of C and the semantics of the x86
language (thus specifying a correct simulation) the call
to HHH(DDD) from the simulated DDD cannot possibly return.

Indeed, that is why it is incorrect.

Would the call from DDDD to ExecuteInput(DDDD) return?

Irrelevent, unless HHH is just an UNCONDITIONAL emulator, at which point
it doesn't answer.

You seem big on making bad analogies, probably because you just don't
know what you are talking about.

// This is ordinary C and I compiled and ran it.

typedef void (*ptr)();

void ExecuteInput(ptr x)
{
  x();
}

void DDDD()
{
  ExecuteInput(DDDD);
  return;
}

int main()
{
  ExecuteInput(DDDD);
}

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

On 8/4/24 8:33 AM, olcott wrote:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>      If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would never >>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

In other words, you don't have an actual program, since it doesn't have
fixed behavior.

Sorry, you just blew up your shambles of a "proof".

You just created an infinite set of problems, where EVERY DDD of an HHH
that emulates for a finite number of steps is Halting (because its HHH
DOES return after a finite time) and thus thos HHH are WRONG to sau
non-halting and the HHH that emulates for an infinite number of steps is
wrong because it will not answer.

This just proves that you method fails, which is bad, since for this set
of problems, an HHH that just immediately returns 1 would be correct, so
there IS a correct answer that an HHH can give, so it isn't even a case
of a pathological input.

Sorry, you are just proving yourself to be just wrong.

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

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>      If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would never >>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

--
Mikko

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

On 2024-08-04 12:30:26 +0000, olcott said:

On 8/4/2024 1:11 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:01 schreef olcott:

On 8/3/2024 9:54 AM, Fred. Zwarts wrote:>>>

Talking nonsense does not hide you problem. I don't disagree with that >>>> semantics.
It is HHH that deviates from the semantics of the x86 language by
skipping the last few instructions of a halting program, changing its
behaviour in this way.

There are no last few instructions of any halting program
that DDD correctly emulated by HHH skips.

Why substituting facts by dreams?
DDD halts when HHH halts. HHH skips tte last cycle of the simulated
HHH,after which it would return to DDD, which would then return too.

Within the semantics of C and the semantics of the x86
language (thus specifying a correct simulation) the call
to HHH(DDD) from the simulated DDD cannot possibly return.

Indeed, that is why it is incorrect.

Would the call from DDDD to ExecuteInput(DDDD) return?

// This is ordinary C and I compiled and ran it.

typedef void (*ptr)();

void ExecuteInput(ptr x)
{
x();
}

void DDDD()
{
ExecuteInput(DDDD);
return;
}

int main()
{
ExecuteInput(DDDD);
}

Most likely it will abort or clrash for stack overflow. A compiler may
detect that the functions have no side effects and no return value and
traslate them as

void DDDD() {
reurn;
}

or, if it also detects that there is a indirect infinite recursion,
as

void DDDD() {
LOOP: goto LOOP;
}

but your compiler doesn't think so much.

--
Mikko

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

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>      If simulating halt decider H correctly simulates its input D >>>>>>      until H correctly determines that its simulated D would never >>>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as
correctely determined by HHH1 or simly calling it from main. It is
not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

--
Copyright 2024 Olcott

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

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

On 8/5/2024 2:23 AM, Mikko wrote:

On 2024-08-04 12:30:26 +0000, olcott said:

On 8/4/2024 1:11 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:01 schreef olcott:

On 8/3/2024 9:54 AM, Fred. Zwarts wrote:>>>

Talking nonsense does not hide you problem. I don't disagree with
that semantics.
It is HHH that deviates from the semantics of the x86 language by
skipping the last few instructions of a halting program, changing
its behaviour in this way.

There are no last few instructions of any halting program
that DDD correctly emulated by HHH skips.

Why substituting facts by dreams?
DDD halts when HHH halts. HHH skips tte last cycle of the simulated
HHH,after which it would return to DDD, which would then return too.

Within the semantics of C and the semantics of the x86
language (thus specifying a correct simulation) the call
to HHH(DDD) from the simulated DDD cannot possibly return.

Indeed, that is why it is incorrect.

Would the call from DDDD to ExecuteInput(DDDD) return?

// This is ordinary C and I compiled and ran it.

typedef void (*ptr)();

void ExecuteInput(ptr x)
{
   x();
}

void DDDD()
{
   ExecuteInput(DDDD);
   return;
}

int main()
{
   ExecuteInput(DDDD);
}

Most likely it will abort or clrash for stack overflow.

YES

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

int main()
{
HHH(DDD);
}

Just like DDD correctly emulated by HHH never reaches its
own "return" instruction halt state, DDDD never reaches its
own "return" instruction halt state. ExecuteInput() is a
proxy for HHH.

_ExecuteInput()
[00002157] 55 push ebp
[00002158] 8bec mov ebp,esp
[0000215a] ff5508 call dword [ebp+08] ; call DDDD
[0000215d] 5d pop ebp
[0000215e] c3 ret
Size in bytes:(0008) [0000215e]

_DDDD()
[00002167] 55 push ebp
[00002168] 8bec mov ebp,esp
[0000216a] 6867210000 push 00002167 ; push DDDD
[0000216f] e8e3ffffff call 00002157 ; call execute input
[00002174] 83c404 add esp,+04
[00002177] 5d pop ebp
[00002178] c3 ret
Size in bytes:(0018) [00002178]

_main()
[00002187] 55 push ebp
[00002188] 8bec mov ebp,esp
[0000218a] 6867210000 push 00002167 ; push DDDD
[0000218f] e8c3ffffff call 00002157 ; call ExecuteInput
[00002194] 83c404 add esp,+04
[00002197] 33c0 xor eax,eax
[00002199] 5d pop ebp
[0000219a] c3 ret
Size in bytes:(0020) [0000219a]




--
Copyright 2024 Olcott

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

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

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>      If simulating halt decider H correctly simulates its input D >>>>>>>      until H correctly determines that its simulated D would never >>>>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>
DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>> not possible to correctly determine that ha haling computation is
non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.

--
Mikko

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

On 8/6/2024 6:54 AM, Richard Damon wrote:

On 8/6/24 7:35 AM, olcott wrote:

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination
analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would >>>>>>>>>> never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>> 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>>>>> not possible to correctly determine that ha haling computation is >>>>>>>>> non-halting, as is self-evdent from the meaning of the words. >>>>>>>>>

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
   HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.
that

I am hypothesizing. If you do know C well enough to agree then
simply agree. What I said is a tautology thus disagreement <is> error.

And, if it *IS* a tautoligy, then you agree that "Correct Simulation"
means a simulation that doesn't abort,

Your attention deficit order continues to cause you to forget
most of the details that I told you hundreds of times.

A correct emulation of 0 to infinity lines of DDD is
a correct emulation of 0 to infinity lines of DDD.

A correct simulation of N lines of DDD is sufficient to
determine that no correct simulation of DDD by any HHH
will ever stop running unless aborted.

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

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

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination
analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>>      until H correctly determines that its simulated D would never >>>>>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>>> not possible to correctly determine that ha haling computation is >>>>>>> non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
   HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.

I am hypothesizing. If you do know C well enough to agree then
simply agree. What I said is a tautology thus disagreement <is> error.

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

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

On 8/6/24 7:35 AM, olcott wrote:

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination
analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>>>      until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>>>> not possible to correctly determine that ha haling computation is >>>>>>>> non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
   HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.
that

I am hypothesizing. If you do know C well enough to agree then
simply agree. What I said is a tautology thus disagreement <is> error.

And, if it *IS* a tautoligy, then you agree that "Correct Simulation"
means a simulation that doesn't abort, and that you have been lying when
you say that all the HHHs that abort and answer did a "Correct Simulation".

Sorry, you are just proving how ignorant you are of what you talk about,
and you make it painfully obvious that you are just a pathological liar.

Your logic has gotten so bad that the errors are just too obvious, and
the fact that you just keep repeating the same disproven claims proof
that you are just an idiot that is incapable of learning.

Sorry.

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

On 2024-08-06 11:35:51 +0000, olcott said:

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers* >>>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>>      If simulating halt decider H correctly simulates its input D >>>>>>>>>      until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>>>> not possible to correctly determine that ha haling computation is >>>>>>>> non-halting, as is self-evdent from the meaning of the words.

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
   HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.

I am hypothesizing.

You were and still are lying. There was no word (such as "assume") in
your calim about me, so it was not a hypothesis but a lie.

--
Mikko

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

On 8/7/2024 2:12 AM, Mikko wrote:

On 2024-08-06 11:35:51 +0000, olcott said:

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination
analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would >>>>>>>>>> never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>> 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>>>>> not possible to correctly determine that ha haling computation is >>>>>>>>> non-halting, as is self-evdent from the meaning of the words. >>>>>>>>>

[Who here is too stupid to know that DDD correctly simulated
  by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
   HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.

I am hypothesizing.

You were and still are lying. There was no word (such as "assume") in
your calim about me, so it was not a hypothesis but a lie.

Several of your answers seemed to show that you did not
know C very well. Fred and Joes did not seem to know
programming very well.

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

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

On 2024-08-07 13:14:13 +0000, olcott said:

On 8/7/2024 2:12 AM, Mikko wrote:

On 2024-08-06 11:35:51 +0000, olcott said:

On 8/6/2024 3:07 AM, Mikko wrote:

On 2024-08-05 12:45:11 +0000, olcott said:

On 8/5/2024 2:27 AM, Mikko wrote:

On 2024-08-04 12:33:20 +0000, olcott said:

On 8/4/2024 2:15 AM, Mikko wrote:

On 2024-08-03 13:48:12 +0000, olcott said:

On 8/3/2024 3:06 AM, Mikko wrote:

On 2024-08-02 02:09:38 +0000, olcott said:

*This algorithm is used by all the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

DDD is correctly emulated by HHH according to the x86
language semantics of DDD and HHH including when DDD
emulates itself emulating DDD

*UNTIL*

HHH correctly determines that never aborting this
emulation would cause DDD and HHH to endlessly repeat.

The determination is not correct. DDD is a halting computation, as >>>>>>>>>> correctely determined by HHH1 or simly calling it from main. It is >>>>>>>>>> not possible to correctly determine that ha haling computation is >>>>>>>>>> non-halting, as is self-evdent from the meaning of the words. >>>>>>>>>>

[Who here is too stupid to know that DDD correctly simulated >>>>>>>>>   by HHH cannot possibly reach its own return instruction?]

Who here is too stupid to know that whether DDD can reach its
own return instruction depends on code not shown below?

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

It is stipulated that HHH is an x86 emulator the emulates
N instructions of DDD where N is 0 to infinity.

That is not stipulated above. Anyway, that stipulation would not
alter the correctness of my answer.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
   HHH(DDD);
}

In other words you do not know C well enough to comprehend
that DDD correctly simulated by any HHH cannot possibly reach
its own "return" instruction halt state.

You are lying again.

I am hypothesizing.

You were and still are lying. There was no word (such as "assume") in
your calim about me, so it was not a hypothesis but a lie.

Several of your answers seemed to show that you did not
know C very well. Fred and Joes did not seem to know
programming very well.

According to our defamation laws "seemed" is not sufficinet to ensure
that you aren't jailed.

--
Mikko

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