Re: Halting Problem: What Constitutes Pathological Input

On 5/6/25 2:05 PM, olcott wrote:

On 5/6/2025 5:59 AM, Richard Damon wrote:

On 5/5/25 10:18 PM, olcott wrote:

On 5/5/2025 8:59 PM, dbush wrote:

On 5/5/2025 8:57 PM, olcott wrote:

On 5/5/2025 7:49 PM, dbush wrote:

>
Which starts with the assumption that an algorithm exists that performs the following mapping:
>
>
Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:
>
A solution to the halting problem is an algorithm H that computes the following mapping:
>
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly
>
>
>

DO COMPUTE THAT THE INPUT IS NON-HALTING
IFF (if and only if) the mapping FROM INPUTS
IS COMPUTED.

>
i.e. it is found to map something other than the above function which is a contradiction.
>

>
The above function VIOLATES COMPUTER SCIENCE.
You make no attempt to show how my claim
THAT IT VIOLATES COMPUTER SCIENCE IS INCORRECT
you simply take that same quote from a computer
science textbook as the infallible word-of-God.

>
All you are doing is showing that you don't understand proof by contradiction,

>
Not at all. The COMPUTER SCIENCE of your requirements IS WRONG!
>

>
No, YOU don't understand what Computer Science actually is talking about.
>

 Every function computed by a model of computation
must apply a specific sequence of steps that are
specified by the model to the actual finite string
input.

Right, "Computed by a model of computation", that

 HHH(DD) must emulate DD according to the rules
of the x86 language.

Right, which is doesn't do.
Remember, your HHH stop processing at a CALL HHH instruction.
Per the Intel Assembly reference manual, 6.4.2
When executing a far call, the processor performs these actions (see Figure 6-2):
1. Pushes the current value of the CS register on the stack.
If shadow stack is enabled:
a. Temporarily saves the current value of the SSP register internally and aligns the SSP to the next 8 byte
boundary.
b. Pushes the current value of the CS register on the shadow stack.
c. Pushes the current value of LIP (CS.base + EIP) on the shadow stack.
d. Pushes the internally saved value of the SSP register on the shadow stack.
2. 3. 4. 5. 1. 2. Pushes the current value of the EIP register on the stack.
Loads the segment selector of the segment that contains the called procedure in the CS register.
Loads the offset of the called procedure in the EIP register.
Begins execution of the called procedure.
Note the last sentence: *Begins* *execution* *of* *the* *called* *procedure.*

THIS DOES DERIVE THAT THE CORRECTLY EMULATED DD DOES NOT HALT.

No, DD, correctly emulatee, as shown by your traces of HHH1(DD) show that is DOES halt.

 That everyone here thinks that HHH can simply ignore
the rules of the x86 language and jump over the "call"
instruction to the "ret" instruction seems quite stupid
to me.

No one but you thinks that. How do you justify your claims when you don't follow your own words.

 _DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]
 

And your omitting of the code of HHH that must be included in the input just shows how ignorant you are of the meaning of a program.
You are just proving that you think lying and equivocating are valid logic principles.
Sorry, you are just proving you are just a damned stupid liar with a ticket to the lake of fire.