Op 29.mei.2025 om 17:37 schreef olcott:

HHH is a simulating termination analyzer that uses
an x86 emulator to emulate its input. HHH is capable
of emulating itself emulating DDD.

HHH is executed within the x86utm operating system
that enables any C function to execute another C
function in debug step mode.

*Here is the fully operational code* https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

<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

It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR.

Indeed, but the input given to HHH is a pointer to memory starting with
the code of DDD. DDD has the addresses of the functions it calls, so
those functions are also available to HHH. This program includes the
code where the program aborts and halts. If HHH would correctly analyse
this input, it would see that no abort is needed. Even without abort by
the simulating HHH, the simulated HHH would abort and make the program
halt. (Unless the input is changed, but that is a change of subject.)
So, your tautology does not apply for this input.
It is a verified fact that due to a bug in HHH it does not see the full specification of the input, in particular not the part with the abort.
That HHH does not see that part does not take away that this abort is
part of the specification in the input.

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

On 5/29/25 11:37 AM, olcott wrote:

HHH is a simulating termination analyzer that uses
an x86 emulator to emulate its input. HHH is capable
of emulating itself emulating DDD.

So, since HHH hand DDD have been admitted to not be programs, they can't
do ANYTHING or be emulated.

HHH is executed within the x86utm operating system
that enables any C function to execute another C
function in debug step mode.

But you can only do that to actual computations, that is C functions
that include all the code they reference.

Since DDD doesn't that just makes the work that HHH does incorrect.

*Here is the fully operational code* https://github.com/plolcott/x86utm/blob/master/Halt7.c

Right, which as explaieed many times, just shows that you have been
LYING for years about your claims that HHH does what you claim.

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

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

<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

Which since those only apply to PROGRAMS< of which neither your H or D
are, it isn't applicatable.

It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR.

Right, once H and D are fully programs. If H does continue simulating
its input until it can actually PROVE that its input will be
non-halting, it can never abort. Because, if H ever aborts and returns
0, its input WILL stop running and reach its return statement, just
after the point that H stopped looking at its input.

If you replace the H with your hypothetical H, but keep the same input
(which has been made into a full program by including all the code of
the actual H, the one that does abort and return 0) then they
hypothetical H will see the simulation of the input reach a final state.

Thus, no H that aborts and returns 0 can ever have corrected determined
its input will not halt.

Your logic is just based on you lying about what you are doing, and
starting with a category error.

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

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

Op 29.mei.2025 om 18:00 schreef olcott:

On 5/29/2025 10:46 AM, Fred. Zwarts wrote:

Op 29.mei.2025 om 17:37 schreef olcott:

HHH is a simulating termination analyzer that uses
an x86 emulator to emulate its input. HHH is capable
of emulating itself emulating DDD.

HHH is executed within the x86utm operating system
that enables any C function to execute another C
function in debug step mode.

*Here is the fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

<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

It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR.

Indeed, but the input given to HHH is a pointer to memory starting
with the code of DDD. DDD has the addresses of the functions it calls,
so those functions are also available to HHH.

None-the-less the tautology remains true and thus
cannot be correctly denied.

This program includes the code where the program aborts and halts. If
HHH would correctly analyse this input, it would see that no abort is
needed.

If the outermost HHH does not abort its simulated DDD
then the simulated DDD, the executed DDD() and the executed
HHH() never stop running. That you cannot understand that
this is factual is no rebuttal what-so-ever.

But the innermost HHH has code to abort. Whether that is good or bad is
not interesting, the point is: it is there.
So, there is no need for the outermost HHH to abort and by this bug it
misses the fact the innermost HHH already has an abort in its code.
That you cannot understand the verified fact that the simulation of an
aborting simulator does not need an abort. Remove the non-aborting HHH
from your brain. It confuses your thinking. There is no such HHH in this problem. There is only a buggy HHH that aborts, which therefore does not
need an abort when simulated.

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

On 5/29/25 8:13 PM, olcott wrote:

On 5/29/2025 7:05 PM, Ross Finlayson wrote:

On 05/29/2025 08:37 AM, olcott wrote:

HHH is a simulating termination analyzer that uses
an x86 emulator to emulate its input. HHH is capable
of emulating itself emulating DDD.

HHH is executed within the x86utm operating system
that enables any C function to execute another C
function in debug step mode.

*Here is the fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

<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

It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR.

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

No it's not.

(Was, "disagreeing with tautologies is always incorrect".)

It's the _deductive_ analysis that makes for the
"analytical bridges" to escape an "inductive impasse".

If by inductive impasse you are referring to mathematical
induction you might be right. If you are referring to logical
induction then you are wrong.

But "Inductive Logic" isn't actually logic in the formal sense, but ways
to try to approximate a correct answer when deductive logic can't get
one. Since Deductive Logic DOES determine the correct answer, just one
you don't like, you are just rejecting actual logic and adopting a
system that you can lie in.

So far I have not been able to make a proof by mathematical
induction that I am correct.

Because it is impossible to correctly prove a wrong statement.

The closest that I got is that for any value of N when
N steps of DDD are correctly emulated by HHH the emulated
DDD never reaches its own "ret" instruction final halt state.

But the problmm here is that your system, when properly defined for H to actually be that series of programs, and D to be the programs built on
those H, it becomes immediately apparant that you aren't talking about
hte SAME D in each of those steps, so just talking about D as a singular
entity is just a category error.

Making D to be a program fragment which is completed in each instance to
try and make D be something singular, just runs afoul of the
requirements that it be a program, and then H needs to not be the
required computation (which can only operate on what it in the input,
and not other outside resource, like other things in memory) as it looks outside to code of the input to "correctly simulate" it.

Thus, what you have proven is not that any of those D are non-halting
(since every D was different), but that no H can prove such a D to be
halting by thing method, even though we CAN, outside of the code of H,
make that proof.

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

On 5/30/25 10:59 AM, olcott wrote:

On 5/30/2025 3:36 AM, Fred. Zwarts wrote:

Op 29.mei.2025 om 18:00 schreef olcott:

On 5/29/2025 10:46 AM, Fred. Zwarts wrote:

Op 29.mei.2025 om 17:37 schreef olcott:

HHH is a simulating termination analyzer that uses
an x86 emulator to emulate its input. HHH is capable
of emulating itself emulating DDD.

HHH is executed within the x86utm operating system
that enables any C function to execute another C
function in debug step mode.

*Here is the fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

<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

It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR.

Indeed, but the input given to HHH is a pointer to memory starting
with the code of DDD. DDD has the addresses of the functions it
calls, so those functions are also available to HHH.

None-the-less the tautology remains true and thus
cannot be correctly denied.

This program includes the code where the program aborts and halts.
If HHH would correctly analyse this input, it would see that no
abort is needed.

If the outermost HHH does not abort its simulated DDD
then the simulated DDD, the executed DDD() and the executed
HHH() never stop running. That you cannot understand that
this is factual is no rebuttal what-so-ever.

But the innermost HHH has code to abort. Whether that is good or bad
is not interesting, the point is: it is there.

You are too dumb to know that this code is unreachable.
Either the outermost HHH aborts or none of them abort
because they all of the exact same code.

Yes, the code is unreachable because the call instruction is unsimulatable.

Fix that by including the code of the HHH that is claimed to give the
right answer, and then the code is reachable, just not by the partial simulation done by that HHH.

Thus, you just prove that you "logic" is built on error and lies.

So, there is no need for the outermost HHH to abort and by this bug it
misses the fact the innermost HHH already has an abort in its code.
That you cannot understand the verified fact that the simulation of an
aborting simulator does not need an abort. Remove the non-aborting HHH
from your brain. It confuses your thinking. There is no such HHH in
this problem. There is only a buggy HHH that aborts, which therefore
does not need an abort when simulated.

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