On 5/22/2022 12:36 PM, Richard Damon wrote:
> On 5/22/22 12:42 PM, olcott wrote:
>> On 5/22/2022 11:40 AM, Richard Damon wrote:
>>> On 5/22/22 12:31 PM, olcott wrote:
>>>> On 5/22/2022 11:21 AM, Richard Damon wrote:
>>>>> On 5/22/22 10:57 AM, olcott wrote:
>>>>>> On 5/22/2022 6:06 AM, Richard Damon wrote:
>>>>>>> On 5/22/22 1:02 AM, olcott wrote:
>>>>>>>> On 5/21/2022 11:05 PM, Richard Damon wrote:
>>>>>>>>> On 5/21/22 11:59 PM, olcott wrote:
>>>>>>>>>> On 5/21/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/21/22 11:36 PM, olcott wrote:
>>>>>>>>>>>> On 5/21/2022 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/21/22 10:48 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/21/2022 9:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/21/22 10:28 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 5/21/22 9:23 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>>>> simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only
>>>>>>>>>>>>>>>>>>>>> for the one case you
>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong,
>>>>>>>>>>>>>>>>>>>>> because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When we correctly reverse-engineer what the
>>>>>>>>>>>>>>>>>>>> execution trace of the input to H(P,P) would be for
>>>>>>>>>>>>>>>>>>>> one emulation and one nested emulation we can see
>>>>>>>>>>>>>>>>>>>> that the correctly emulated input to H(P,P) would
>>>>>>>>>>>>>>>>>>>> never reach its final state at machine address
>>>>>>>>>>>>>>>>>>>> [0000136c].
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A nonsense trace, as it is mixing the execution path
>>>>>>>>>>>>>>>>>>> of two independent execution units.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In other words you acknowledge that you are
>>>>>>>>>>>>>>>>>> technically incompetent to provide the execution trace
>>>>>>>>>>>>>>>>>> of one simulation and one nested simulation of the
>>>>>>>>>>>>>>>>>> input to H(P,P).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, I am saying that you are asking for the equivalent
>>>>>>>>>>>>>>>>> of a of a square circle.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So an execution trace of the input to H(P,P) is easy to
>>>>>>>>>>>>>>>> show when H simulates its input, yet another execution
>>>>>>>>>>>>>>>> trace of the input to H(P,P) that was invoked by P is
>>>>>>>>>>>>>>>> "like a square circle" can't possibly exist?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The problem is that your second trace is NOT a piece of
>>>>>>>>>>>>>>> the first.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact you don't understand that says you just don't
>>>>>>>>>>>>>>> know how computers or programs actually work.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When a UTM simulates a TM description that calls a UTM
>>>>>>>>>>>>>> that simulates a
>>>>>>>>>>>>>> TM description all of this is simply data on the first
>>>>>>>>>>>>>> UTM's tape and the only actual executable is the first UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, and a trace made by that outer UTM will show the
>>>>>>>>>>>>> states that the second UTM is going through, but NOT the
>>>>>>>>>>>>> states that second UTM simulates in its own processing.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That second UTM might produce its OWN trace of the states
>>>>>>>>>>>>> that it has simulated, but that is a SEPERATE trace, and
>>>>>>>>>>>>> NOT part of the trace from the OUTER UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And this trace is written to the outer UTM's tape as a part
>>>>>>>>>>>> of its own data.
>>>>>>>>>>>
>>>>>>>>>>> Yes, the DATA is there, ENCODED on the tape, but it isn't
>>>>>>>>>>> part of the trace generated by that UTM.
>>>>>>>>>>
>>>>>>>>>> The only actual executable is the outer UTM everything else is
>>>>>>>>>> a part of the same nested process.
>>>>>>>>>
>>>>>>>>> So the only actual valid trace is what that outer simulator
>>>>>>>>> actual simulated.
>>>>>>>>>
>>>>>>>>
>>>>>>>> There is a valid trace of every line of code that is emulated.
>>>>>>>> Operating system code has its trace tuned off. This only leaves
>>>>>>>> the user code such as P() and main(). Then we see the 14 lines
>>>>>>>> execution trace of the two level simulation of the input to H(P,P)
>>>>>>>
>>>>>>> No, because the second level emulation is NOT emulated by the top
>>>>>>> level emulator, its emulator is.
>>>>>>>
>>>>>>> Unless you are lying about what H does, you are just lying that
>>>>>>> the second level code is emulated by the same emulation process
>>>>>>> that the first is. (That may well be true, but it means you logic
>>>>>>> is still built on a lie).
>>>>>>>
>>>>>>
>>>>>> If you are too stupid to understand that H(P,P) derives the same
>>>>>> execution trace of its input every time it is called you are far
>>>>>> too stupid to evaluate my work.
>>>>>
>>>>> Ok, then why does the H(P,P) that P calls get stuck in an infinite
>>>>> recursion wneh the top level doesn't?
>>>>
>>>> It is a verified fact that the correct simulation of the input to
>>>> H(P,P) never reaches its final instruction thus conclusively proving
>>>> that it never halts.
>>>>
>>>
>>> The only machine that you have shown that does a correct simulation
>>> is the version that never aborts. That version fails to answer the
>>> question, so fails to be a halt decider.
>>>
>>> Any version of H that aborts, and returns a not-halting answer
>>> changes P into a Halting Compuation.
>>>
>>> The "pathological" use of H by P lets it change as you change H, so
>>> if H aborts, it is wrong because THAT P halts, if it doesn't, then it
>>> is wrong for not answering.
>>>
>>> You seem to miss this fact because you just don't understand the
>>> basics of how computations work. Part of your problem is you keep on
>>> trying to define H by rules that aren't an actual algorithm, so can't
>>> actually be written.
>>>
>>
>>
>>
>> It is an easily verifiable fact that the C function H does correctly
>> determine that the C function named P would never reach its last
>> instruction when correctly emulated by H.
>
> Don't just "Claim" it, so an ACTUAL verification, or you just show
> yourself to be a liar.
>
>>
>> Everyone disagreeing with verified facts is incorrect on the basis of
>> lack of technical competency or lack of honesty.
>
> You haven't verified ANY fact, you have made claims using FAKE data that
> don't even really support your claim.
>

Software engineering experts
can reverse-engineer what the correct x86 emulation of the input to
H(P,P) would be for one emulation and one nested emulation thus
confirming that the provided execution trace is correct. They can do
this entirely on the basis of the x86 source-code for P with no need to
see the source-code or execution trace of H.

Anyone unable to do this conclusively proves their lack of sufficient
technical competence.

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]

Richard was able to correctly determine that the correct simulation of
the input to H(P,P) would emulate the first 7 lines of P.

Richard was utterly baffled beyond all comprehension that the invocation
of the same function with the same input would derive the same trace.

Richard even said that this trace is "like a square circle" in that it
cannot possibly exist.

Does anyone here believe that Richard is really that stupid? (I don't).

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer