On 4/14/22 6:16 PM, olcott wrote:
> On 4/14/2022 3:54 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/14/2022 11:40 AM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/14/2022 9:30 AM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/13/2022 6:02 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/13/2022 2:38 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> The simulated input to H(P,P) is non halting.
>>>>>>>>>>
>>>>>>>>>> Then you are either (a) doing it wrong, or (b) wrong to have
>>>>>>>>>> said that
>>>>>>>>>> P(P) halts.  Oh, there is a third (c) you are using poetic
>>>>>>>>>> license, and
>>>>>>>>>> simulating the input means something silly.  It's literal
>>>>>>>>>> nonsense to
>>>>>>>>>> there's a lot of scope for you make up some silly meaning.
>>>>>>>>>
>>>>>>>>> When mere rhetoric goes against easily verified facts rhetoric
>>>>>>>>> loses:
>>>>>>>>
>>>>>>>> Your own claim: H(P,P) == false is "correct" even though P(P)
>>>>>>>> halts.
>>>>>>>> That's not rhetoric.  You've been too clear about this attempt.
>>>>>>>> You
>>>>>>>> need to try a new ruse.
>>>>>>>
>>>>>>> Because the input to H(P,P) is non-halting then nothing in the
>>>>>>> universe can possibly contradict the fact that it is non-halting.
>>>>>>
>>>>>> Being generous, the "input" to H in the call H(P,P) is just two
>>>>>> pointers.  They are neither halting nor non-halting -- they are just
>>>>>> pointers.
>>>>>>
>>>>>> Up until, now I was prepared to take your words metaphorically, but
>>>>>> since you duck the key question of what "the input to H(P,P) is
>>>>>> non-halting" means,
>>>>>
>>>>> Sure when I make to to explain ever details many hundreds of times
>>>>> damned liars will say that I never mentioned any of this.
>>>> Just use the right terms.  H(P,P) has not input.  The call has
>>>> arguments.  They are just pointers.  Pointers are not halting nor are
>>>> they non halting.  Given that this mantra is the core of what you are
>>>> now claiming, I would have thought you would want to avoid it being
>>>> patentent nonsense.
>>>>
>>>>> The input to H is the only way that finite strings can be passed to a
>>>>> "C" function and points to the finite string of the machine code of P.
>>>> H has no input.  Do you mean the two pointer arguments?
>>>>
>>>>> The simulating halt decider H uses an x86 emulator to simulate its
>>>>> input (P,P) and finds that it would never reach its own final state in
>>>>> an unlimited number of simulated steps.
>>>>
>>>> (P,P) is too vague.  What needs to be simulated is the first pointer
>>>> being called as a function with the second as it's argument.  I.e. the
>>>> call P(P) is what should be simulated.
>>>
>>> That the correctly simulated input to H(P,P) cannot possibly reach its
>>> own final state proves that this input is not-halting.
>>>
>>> Adding all of the tedious details that you suggest does not change
>>> this fact.
>>
>> If you add all the corrections, sorry, "tedious details", it contradicts
>> what you've said in the past.  With the errors left in place, the naive
>> reader won't knowing exactly what's being said -- and I think that's
>> deliberate.
>>
>> For example, why talk about simulation at all since simulations of
>> computations halt or don't halt if and only if the computations do
>> themselves?  Well, it adds yet another puff of smoke to the mirrors
>> you've got in there already like what that "its" refers to (since
>> nothing here has a final state), or what non-halting pointers are.
>>
>> "The input to H(P,P)" should mean the two pointers, P and P.  Simulating
>> them should mean simulating the call P(P) and the simulation "not
>> reaching its own final state" should mean that the simulation of P(P)
>> does not halt.  And that happens if, and only if, the call P(P) itself
>> does not halt.
>>
>> I honestly have no idea if that is what you mean, but if it is, it's
>> wrong because P(P) halts.  You are probably just trying to cover that
>> up.
>>
>
> That a non input halts, converts the world to Fascism or opens a very
> popular brothel is totally unrelated to the easily confirmed fact that
> the input to H(P,P)* does not halt.

WHAT NON-INPUT.

>
> *standard functional notation
>
> _P()
> [00000956](01)  55              push ebp
> [00000957](02)  8bec            mov ebp,esp
> [00000959](03)  8b4508          mov eax,[ebp+08]
> [0000095c](01)  50              push eax       // push P
> [0000095d](03)  8b4d08          mov ecx,[ebp+08]
> [00000960](01)  51              push ecx       // push P
> [00000961](05)  e8c0feffff      call 00000826  // call H(P,P)
> The above keeps repeating until aborted

PROVING THAT YOU AREN'T LOOKING AT A CORRECT SIMULATION.

>
>
> [00000966](03)  83c408          add esp,+08
> [00000969](02)  85c0            test eax,eax
> [0000096b](02)  7402            jz 0000096f
> [0000096d](02)  ebfe            jmp 0000096d
> [0000096f](01)  5d              pop ebp
> [00000970](01)  c3              ret            // final state.
> Size in bytes:(0027) [00000970]
>
>
>

Here is your previously posted CORRECT SIMULATION:

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)