Re: Every sufficiently competent C programmer knows --- Paraphrase of Sipser's agreement

On 3/16/25 2:26 PM, olcott wrote:

On 3/16/2025 6:33 AM, Richard Damon wrote:

On 3/15/25 5:27 PM, olcott wrote:

On 3/15/2025 5:12 AM, Mikko wrote:

On 2025-03-14 14:39:30 +0000, olcott said:
>

On 3/14/2025 4:03 AM, Mikko wrote:

On 2025-03-13 20:56:22 +0000, olcott said:
>

On 3/13/2025 4:22 AM, Mikko wrote:

On 2025-03-13 00:36:04 +0000, olcott said:
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
When HHH correctly emulates N steps of the
above functions none of them can possibly reach
their own "return" instruction and terminate normally.

>
Nevertheless, assuming HHH is a decider, Infinite_Loop and Infinite_Recursion
specify a non-terminating behaviour, DDD specifies a terminating behaviour

>
_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]
>
What is the sequence of machine language
instructions of DDD emulated by HHH such that DDD
reaches its machine address 00002183?

>
Irrelevant off-topic distraction.

>
Proving that you don't have a clue that Rice's Theorem
is anchored in the behavior that its finite string input
specifies. The depth of your knowledge is memorizing
quotes from textbooks.

>
Another irrelevant off-topic distraction, this time involving
a false claim.
>
One can be a competent C programmer without knowing anyting about Rice's
Theorem.
>

>
YES.
>

Rice's Theorem is about semantic properties in general, not just behaviours.
The unsolvability of the halting problem is just a special case.
>

>
A property about Turing machines can be represented as the language of all Turing machines, encoded as strings, that satisfy that property.
http://kilby.stanford.edu/~rvg/154/handouts/Rice.html
>
Does THE INPUT TO simulating termination analyzer
HHH encode a C function that reaches its "return"
instruction [WHEN SIMULATED BY HHH] (The definition
of simulating termination analyzer) ???

>
Then your idea of a "simulating termination analyzer" isn't what anyone else would define one to be, and th
>

>
<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>

>
Right, when it determines that the CORRECT SIMULATION of the program given to it.
>
That means D is a program, and thus is includes all its code, including the code for H, and

 The semantics of the C/x86 programming languages
specify what a correct simulation/emulation is.

Right, and that exactly matches the direct execution of the code, and requires that all the code used is provided.

 Thus DD correctly simulated/emulated by HHH cannot
possibly reach its own "return"/"ret" instruction
and terminate normally.
 

And if HHH is defined to do a correct emulation of its input, it will never return an answer.
And HHH that aborts its emulation, has, BY DEFINITION, not done a correct emulation of the input, and hasn't established what a correct emulation would be.
By the definition of DD, and HHH(DD) that aborts and returns 0, creates a DD that has a correct emulation that halts.
Note, DD will call the exact same version of HHH that is claimed to be correctly deciding it, so no HHH(DD) can be correct returning 0. PERIOD. by the definition you just referenced.
Sorry, you are just stuck with the fact that the ACTUAL definitions of the terms you try to use prove you wrong, because you logic is just based on errors and lies.