Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002192][00103820][00000000] 55         push ebp
[00002193][00103820][00000000] 8bec       mov ebp,esp
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4

We don't show any of HHH and show the execution trace of
of just DDD assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an unconditional
simulator that does not abort.

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>

So, Sipser only agreed to a correct simulation, not with an incorrect simulation that violates the semantics of the x86 language by skipping
the last few instructions of a halting program.

You must have attention deficit disorder if you cannot pay
attention to the fact that I have said these same words many
many times:

    *If simulating halt decider H correctly simulates its input D*
    *until H correctly determines that its simulated D would never*
    *stop running unless aborted*

Yes, you often make the same mistake. Because the examples you show are
about an simulator that thinks that two recursions are enough to decide
an infinite recursion. You should know that two differs from infinite.
Your simulation aborts prematurely, skipping the last few instructions
of its input.

*Either that or you are an internet Troll*

Irrelevant nonsense ignored.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

When we see the first four lines of DDD after main() has
called HHH(DDD) we know that HHH has emulated these first
four lines correctly. >
When we see the first four lines of DDD after DDD() has
called HHH(DDD) we know that HHH has emulated these first
four lines correctly.

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
[00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)

But we miss the trace of the instructions that should follow the call instruction.
Are you cheating? You are hiding that HHH has conditional branch
instructions, which makes it abort after two cycles.

New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Then HHH prints a wrong message after skipping the last few instructions
of its simulation of HHH, after which the simulated HHH would abort and
return to DDD, after which the simulated DDD would halt.
Apparently, HHH is incorrectly programmed to abort a halting program
after two cycles. A premature abort, because one cycle later the
simulated HHH would abort and the program would halt.

So, we see an incorrect simulation, which skips instructions of a
halting program, violating in this way the semantics of the x86 language.

Olcott keeps dreaming of an infinite recursion. He really, really wants
his simulation to be correct. He hopes that repeating and dreaming will
change the fact that it is incorrect. But dreams are no substitute for
logic.
HHH cannot possibly simulate itself correctly.

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

Am Wed, 31 Jul 2024 16:23:09 -0500 schrieb olcott:

On 7/31/2024 3:01 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

We don't show any of HHH and show the execution trace of of just DDD >>>>> assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an unconditional
simulator that does not abort.

This algorithm is used by all the simulating termination analyzers:

So, Sipser only agreed to a correct simulation, not with an incorrect
simulation that violates the semantics of the x86 language by skipping
the last few instructions of a halting program.

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach its own second line.

If HHH can't simulate itself, it is not a decider.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Op 31.jul.2024 om 23:23 schreef olcott:

On 7/31/2024 3:01 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  =========  =============
[00002192][00103820][00000000] 55         push ebp
[00002193][00103820][00000000] 8bec       mov ebp,esp
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call
HHH(DDD)
New slave_stack at:1038c4

We don't show any of HHH and show the execution trace of
of just DDD assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an
unconditional simulator that does not abort.

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>

So, Sipser only agreed to a correct simulation, not with an incorrect
simulation that violates the semantics of the x86 language by skipping
the last few instructions of a halting program.

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

int main()
{
  HHH(DD);
}

DD correctly emulated by HHH cannot possibly reach its own
second line. I switched to DDD correctly emulated by HHH

But it has been proven that no such HHH exists that simulates itself
correctly. So, talking about a correct simulation by HHH is vacuous word
salad.

because only C experts understood the above example and we
never had any of those here.

There are many C experts that looked at it, but you only got critic,
because you keep hiding important properties of HHH, which made the
conclusion impossible. Many C experts are in this newsgroup.
All C experts say: "if HHH halts, then there is no reason why the second
line cannot be reached".
Of course you ignored it, because you you dream of a correct simulation.
But dreams are no substitute for facts.
No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end of a
halting program.

The difference between DDD and DD is irrelevant, because HHH is unable
to reach the code where Halt_Status is used.
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.
When HHH cannot possibly simulate itself correctly, talking about a
correct simulation by HHH is vacuous word salad.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

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

Op 01.aug.2024 om 13:28 schreef olcott:

On 8/1/2024 2:20 AM, joes wrote:

Am Wed, 31 Jul 2024 16:23:09 -0500 schrieb olcott:

On 7/31/2024 3:01 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

We don't show any of HHH and show the execution trace of of just DDD >>>>>>> assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an unconditional >>>>>> simulator that does not abort.

This algorithm is used by all the simulating termination analyzers:

So, Sipser only agreed to a correct simulation, not with an incorrect
simulation that violates the semantics of the x86 language by skipping >>>> the last few instructions of a halting program.

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach its own second line.

If HHH can't simulate itself, it is not a decider.

So we are back to your lack of software engineering skill.

Don't talk about software skill, when you do not even understand the
software written by yourself.

You cannot see that the second instruction of DD correctly*
emulated by HHH cannot possibly be reached by DD. This
remains true no matter how many levels that HHH emulates
itself emulating DD.

Which only shows that the simulation of HHH by itself is incorrect.
Other simulators (such as HHH1) have problem to do it, proving that the
problem is in HHH.

*According to the x86 semantics of DD and HHH

You are running in circles of not understanding the semantics of x86.
HHH simulates only the first few instructions and then skips the last
few instructions of HHH. Skipping instructions of a halting program
(HHH) violates the semantics of x86. Even when the first few
instructions are simulated correctly.
The problem is that HHH cannot possibly simulate itself correctly.
Therefore, it cannot reach the return of the simulated HHH.
A correct simulation of HHH (e.g. by HHH1) shows that the simulation of
HHH can reach its end and then return to DD.
It is incorrect to blame DD for it, because the same problem is also
present in

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

This has been told to you many times, but it seems that you are unable
to learn.

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

Op 01.aug.2024 om 14:34 schreef olcott:

On 8/1/2024 6:46 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 13:28 schreef olcott:

On 8/1/2024 2:20 AM, joes wrote:

Am Wed, 31 Jul 2024 16:23:09 -0500 schrieb olcott:

On 7/31/2024 3:01 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

We don't show any of HHH and show the execution trace of of
just DDD
assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an
unconditional
simulator that does not abort.

This algorithm is used by all the simulating termination analyzers: >>>>

So, Sipser only agreed to a correct simulation, not with an incorrect >>>>>> simulation that violates the semantics of the x86 language by
skipping
the last few instructions of a halting program.

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach its own second
line.

If HHH can't simulate itself, it is not a decider.

So we are back to your lack of software engineering skill.

Don't talk about software skill, when you do not even understand the
software written by yourself.

You cannot see that the second instruction of DD correctly*
emulated by HHH cannot possibly be reached by DD. This
remains true no matter how many levels that HHH emulates
itself emulating DD.

Which only shows that the simulation of HHH by itself is incorrect.

No this only shows that you are a liar.

Irrelevant nonsense (probably written because olcott wants to distract
from the truth) ignored.

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

Op 01.aug.2024 om 15:11 schreef olcott:

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

Op 01.aug.2024 om 14:34 schreef olcott:

On 8/1/2024 6:46 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 13:28 schreef olcott:

On 8/1/2024 2:20 AM, joes wrote:

Am Wed, 31 Jul 2024 16:23:09 -0500 schrieb olcott:

On 7/31/2024 3:01 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

We don't show any of HHH and show the execution trace of of >>>>>>>>>>> just DDD
assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an
unconditional
simulator that does not abort.

This algorithm is used by all the simulating termination
analyzers:

So, Sipser only agreed to a correct simulation, not with an
incorrect
simulation that violates the semantics of the x86 language by
skipping
the last few instructions of a halting program.

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach its own second >>>>>>> line.

If HHH can't simulate itself, it is not a decider.

So we are back to your lack of software engineering skill.

Don't talk about software skill, when you do not even understand the
software written by yourself.

You cannot see that the second instruction of DD correctly*
emulated by HHH cannot possibly be reached by DD. This
remains true no matter how many levels that HHH emulates
itself emulating DD.

Which only shows that the simulation of HHH by itself is incorrect.

No this only shows that you are a liar.

Irrelevant nonsense (probably written because olcott wants to distract
from the truth) ignored.

You are probably an atheist thus don't believe
that lying matters. Richard is not an atheist
yet still seems to think that lying doesn't matter.

I see you are not very good in predictions. Maybe that is also the
reason why the predictions of HHH fail.
Irrelevant ad hominem attack ignored. No relevant contents detected. A
lack of arguments becomes visible.
So, it still stands that HHH cannot possibly simulate itself correctly.

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