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

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 thus when we give D to an actual correct simulation, since you just said your H is going to abort and return non-halting, will see D going into the sub-function H which will simulate for a while and then return 0 just like H does, and then we see that D will Halt.
Thus, the claim that H correctly determined that its simulated D would never stop running unless aborted.
Of course the biggest part of the problem is that in your system, H and D aren't actually programs to begin with, so you begin with a category error in your logic.

 <Accurate Paraphrase>
     If emulating termination analyzer H emulates its input
     finite string D of x86 machine language instructions
     according to the semantics of the x86 programming language
      until H correctly determines that this emulated D cannot
     possibly reach its own "ret" instruction in any finite
     number of correctly emulated steps then
      H can abort its emulation of input D and correctly report
     that D specifies a non-halting sequence of configurations.
</Accurate Paraphrase>

Nope, just shows your stupidity, since H can't actually determine what you claim it determines unless it lies to itself about what everything is.

 

Memorizing quotes from textbooks is useful for practical purposes but
if it is too hard for you there are other ways.
>

 The whole X represents TM X that halts on its input is inaccurate.
If you did not merely learn-by-rote you would already know this.
 *Input Y to TM Z specifies a TM that halts when directly measured by Z*

Nope, where do you get that from, it seems from your lies. Your whole world seems to be based on make-beleive, because you just don't understand what truth and reality are.
I guess this is why you think you are god even though you also know you can not be god because you can't do what he is supposed to be able to do.
So, you choose to just beleive your own lies and ignore the truth.