Re: Disagreeing with tautologies is always incorrect

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.