On 3/21/25 8:02 PM, olcott wrote:

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]

For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.

So, you demonstrate your utter stupidity and use of incorrect definitions.

For EVERY HHH at machine address 000015d2 that emulates just a finite
number of steps and return, then the PROGRAM DDD WILL reach its own
return instruction, as the behavior of a program is DEFINED by its
direct execution.

All you have done is proven that you statement is self-contradictory, as
any HHH that only emulated a finite number of steps of DDD, doesn't
correctly emulate DDD per the x86 programming language unless it reached
that return instruction, as no x86 instruction says the execution
stopped there, but your emulation did.

So, all you did what establish that you don't understand the meaning of
the words you used.

Note, the bigger problem is that the above DDD is not a "Program" per
the definitions, as it doesn't include all its code, but needs to
inlcude as part of its definition the function you referenced, and thus
each HHH gets a DIFFERENT DDD, and thus you can't compare results of
different HHHs to talk about the behavior of their inputs.

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

On 3/21/25 9:13 PM, olcott wrote:

On 3/21/2025 7:50 PM, Richard Damon wrote:

On 3/21/25 8:02 PM, olcott wrote:

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]

For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.

So, you demonstrate your utter stupidity and use of incorrect
definitions.

For EVERY HHH at machine address 000015d2 that emulates just a finite
number of steps and return, then the PROGRAM DDD

does not exist because HHH is invoked from main()

SO you admit to misdefining your system.

Halt Deciders take PROGRAM (via a finite string representation) as their
input. If DDD isn't a program, you can't ask about its halting behavior.

Note, if HHH is a program, then by the basic princples of programs, it
can be made into a sub-program of another program. That is a basic part
of a system being Turing Complete.

I guess your idea of programs are that your system is not Turing Complete.

Sorry, you are just proving your stupidity.

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

On 2025-03-22 00:02:24 +0000, olcott said:

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]

For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.

When you mark your earlier post as erronous with the number 2 (or any
other way) on the subject line you should tell in the message which
error you found in your ealier posting and how the new posting is
better.

--
Mikko

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

On 2025-03-22 01:13:42 +0000, olcott said:

On 3/21/2025 7:50 PM, Richard Damon wrote:

On 3/21/25 8:02 PM, olcott wrote:

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]

For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.

So, you demonstrate your utter stupidity and use of incorrect definitions. >>
For EVERY HHH at machine address 000015d2 that emulates just a finite
number of steps and return, then the PROGRAM DDD

does not exist because HHH is invoked from main()

A program exists even when never invoded from anywhaere.

--
Mikko

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

On 3/21/25 11:48 PM, olcott wrote:

On 3/21/2025 9:47 PM, Richard Damon wrote:

On 3/21/25 9:13 PM, olcott wrote:

On 3/21/2025 7:50 PM, Richard Damon wrote:

On 3/21/25 8:02 PM, olcott wrote:

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]

For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.

So, you demonstrate your utter stupidity and use of incorrect
definitions.

For EVERY HHH at machine address 000015d2 that emulates just a
finite number of steps and return, then the PROGRAM DDD

does not exist because HHH is invoked from main()

SO you admit to misdefining your system.

typedef void (*ptr)();
int HHH(ptr P);

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

int main()
{
  HHH(DDD);
}

I only admit that you have been dishonestly trying to
get away with the straw-man deception for at least
two years.

Your DDD isn't a program as defined, and if you include Halt7.c as part
of the input,

Halt Deciders take PROGRAM (via a finite string representation) as
their input. If DDD isn't a program, you can't ask about its halting
behavior.

The x86 machine code is the relevant example.
Since Turing machines cannot possibly directly examine
the behavior of other Turing machines halt deciders
must base their entire halting decision on the behavior
that this finite string actually specifies.

They can do the equivalent with a UTM. Note, your problem is the problem
isn't based on what the decider "sees" as behavior, but its attempt to DETERMINE the actual behavior of the thing its input represents.

You seem brain dead on this point.

No, you are, because you refuse to look at the meaning of the actual
problem.

The Halt Decider is to determine if the MACHINE represented by its input
will halt.

Thus, its result MUST be based on the direct execution, which as you
say, can not be directly observed, and thus must be indirectly
determined, This is what makes it a PROBLEM, and not a 1st Grade
exercise. Your problem seems to be that you think the world needs to be
"fair" and not ask for things that can't be done. Sorry, it isn't, and
some problems exist that can't be solved, just like you are going to DIE
soon, and there is nothing you can do about it. Life just isn't fair,
but we need to make the best of it, but it seems you have made the worse.

Note, if HHH is a program, then by the basic princples of programs, it
can be made into a sub-program of another program. That is a basic
part of a system being Turing Complete.

I guess your idea of programs are that your system is not Turing
Complete.

Sorry, you are just proving your stupidity.

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

On 2025-03-22 13:08:55 +0000, olcott said:

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

On 2025-03-22 00:02:24 +0000, olcott said:

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]

For every HHH at machine address 000015d2 that emulates
a finite number of steps of DDD according to the
semantics of the x86 programming language no DDD
ever reaches its own "ret" instruction halt state.

When you mark your earlier post as erronous with the number 2 (or any
other way) on the subject line you should tell in the message which
error you found in your ealier posting and how the new posting is
better.

There was no error The words were not clear enough for Richard.

That the words were not clear enough can be regarded as an error.

What makes you think that the words above are clearer?

--
Mikko

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