On 5/22/22 6:50 PM, olcott wrote:
> On 5/22/2022 5:34 PM, Richard Damon wrote:
>>
>> On 5/22/22 5:59 PM, olcott wrote:
>>> On 5/22/2022 4:34 PM, Richard Damon wrote:
>>>>
>>>> On 5/22/22 5:06 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> Interesting point, that you eed to talk about "reverse-engineering"
>>>> this output implies that you don't actually have a program to
>>>> generate it.
>>>>
>>>
>>> Not at all. This program took me a whole man-year.
>>
>> Then why do we need to "reverse-engineer" the trace?
>>
>
> It is the only way that you can verify that this trace is correct:

Since it ISN"T correct, that is meaningless.

>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
>     machine   stack     stack     machine    assembly
>     address   address   data      code       language
>     ========  ========  ========  =========  =============
> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
> ...[00001358][0021233a][00001352] 50         push eax      // push P
> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][00212336][00001352] 51         push ecx      // push P
> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

ERROR HERE. The code below in not executed as part of the same process
as the code above.
> ...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
> ...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
> ...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
> ...[00001358][0025cd62][00001352] 50         push eax      // push P
> ...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>
>
>>> The most difficult part was to make the nested simulations work
>>> correctly.
>>
>> Which it seems you failed at. Maybe that is why ot took so long. It is
>> hard to make automaticaly believable lies.
>>
>>>
>>>> You don't need to "reverse-engineer" something you have.
>>>>
>>>
>>> No but everyone else does to confirm its correctness because
>>> THEY DON'T HAVE IT.
>>
>> No, you present the trace and people can verify it.
>>
>> Note, it has been pointed out that it does NOT match what you claim is
>> happening, which proves it is WRONG.
>
> THIS HAS NEVER BEEN MORE THAN A BASELESS ASSERTION.

You admit your claim is baseless?

You can't call my claim baseless, as I fully explain my reasoning, which
you do not even attempt to refute, so you must be accepting.

>
>>
>> The trace implies that H just calls its input, and hides its own
>> behavior.
>>
>
> I hrrd code the system to never output the trace of operating system code.

WHAT operationg system code. There is no such thing in a Computation.

The H that P calls is code that is part of the compuation and needs to
be treated as such.

That is one of you big lies.

>
>> If it does that, then it can't abort its trace, or isn't actually a
>> computatiopn. (and we see it aborts, and you claim it is a computatiopn)
>>
>> Thus, the trace is incorrect, or you are lying and the trace doesn't
>> matter.
>>
>>>
>>>>
>>>>>
>>>>> 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.
>>>>
>>>> No, that is NOT what I said, and you repeating that LIE just shows
>>>> you are not intertested in honest answer. I hope what ever review
>>>> looks at your final paper (it you ever get to it) and happens to
>>>> search and come accross these discussions and sees your level of
>>>> dishonesty.
>>>>
>>>
>>> So then you now agree that the nested invocation of H(P,P) would
>>> derive the same execution trace of its input that the the outer one did?
>>>
>>
>> Yes seem to have a confusion. Yes, the second simulator will produce
>> and identical trace to the first one, AS A SEPERATE TRACE.
>
> I don't have any confusion. You have rebuttal of my work as your only
> goal. As soon as I pointed out the a rebuttal of what I said would
> directly contradict computer science you backed down because you knew
> you couldn't get way with it.

I have TRUTH as my goal
>
> So then you agree that the invocation of H(P,P) would derive the
> following trace of its input on the first 7 lines and when P invokes
> another instance of H(P,P) this derives the next 7 lines of execution
> trace.

Nope, you just must be brain dead. (and sounds to be soon real dead).

You don't get to combine traces of different execution levels. The trace
needs to show the "second level" as being conditionally simulated in the
context of the first level, as that is what it is.

You fail fundamental computer science knowledge. Guess they were right
to deny you that degree.

>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:212352
> ...[00001352][0021233e][00212342] 55         push ebp      // enter P
> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
> ...[00001358][0021233a][00001352] 50         push eax      // push P
> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][00212336][00001352] 51         push ecx      // push P
> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H

INCORRECT.

> ...[00001352][0025cd66][0025cd6a] 55         push ebp      // enter P
> ...[00001353][0025cd66][0025cd6a] 8bec       mov ebp,esp
> ...[00001355][0025cd66][0025cd6a] 8b4508     mov eax,[ebp+08]
> ...[00001358][0025cd62][00001352] 50         push eax      // push P
> ...[00001359][0025cd62][00001352] 8b4d08     mov ecx,[ebp+08]
> ...[0000135c][0025cd5e][00001352] 51         push ecx      // push P
> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>
> >> In order to contradict me you must contradict computer science.
>
>