On 2025-03-15 21:27:00 +0000, olcott said:

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

However, it is possible that for some property that language cannot
be presented.

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

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

An attempt to deceive. Professor Sipser is does not say anuthing about
the qestion stated just before the that quote. Instead, is taking
about the halting problem. In particular, the clause "when simulated
by H" is not in the quoted text.

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

The "paraphrase" is not accurate. In particular, the phrase "in any
finite number of correctly emulated steps" is not in Sipsers words.

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.

Can't parse. What is the subject of "is inaccurate"?

If you did not merely learn-by-rote you would already know this.

Usually the word "know" is not used about false beliefs.

*Input Y to TM Z specifies a TM that halts when directly measured by Z*

Which TM halts, Y or Z?

--
Mikko

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

On 2025-03-16 01:28:27 +0000, olcott said:

On 3/15/2025 5:35 PM, dbush wrote:

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

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

But he didn't agree to what you think he did:

THIS IS EXACTLY AND PRECISELY WHAT I THINK HE DID AGREE TO
(It took me years to form this precise paraphrase)

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

That "paraphrase" is not accurate and Sipser did not agree with it.

--
Mikko

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

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.


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

Am Sat, 15 Mar 2025 16:27:00 -0500 schrieb olcott:

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

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.

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.

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

That can't be right. Otherwise my simulator could just not simulate
at all and say that no input halts.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

key word "correctly"

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

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.

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

On 3/16/25 8:46 PM, olcott wrote:

On 3/16/2025 5:50 PM, Richard Damon wrote:

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.

I don't think this is over your head, maybe it is:
HHH can see that DDD will not halt in two complete
emulations.

And is WRONG, because it didn't use valid logic.

Sorry, Once HHH is defined to at some point "see" that claim, it makes
itself wrong because you logic to build that claim used the postulate
that HHH never aborts.

Sorry, when you believe your own lies you just prove how stupid you
really are.

You are so stupid, you can't see how stupid you are.

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