On 5/21/22 11:24 PM, olcott wrote:
> On 5/21/2022 10:12 PM, Richard Damon wrote:
>> On 5/21/22 10:34 PM, olcott wrote:
>>> On 5/21/2022 9:27 PM, Richard Damon wrote:
>>>> On 5/21/22 9:25 PM, olcott wrote:
>>>>> On 5/21/2022 8:16 PM, Richard Damon wrote:
>>>>>> On 5/21/22 9:02 PM, olcott wrote:
>>>>>>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>>>>>>> On 5/21/22 3:12 PM, olcott wrote:
>>>>>>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>>>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the execution
>>>>>>>>>>>>>>>>>>> trace provided by H(P,P) of the nested simulation of
>>>>>>>>>>>>>>>>>>> its input exactly matches the behavior of the
>>>>>>>>>>>>>>>>>>> correctly reverse-engineered nested execution trace
>>>>>>>>>>>>>>>>>>> would be.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>>>>>>> You know that you are a liar so I challenge you to
>>>>>>>>>>>>>>>>> provide the execution trace that a pure single level
>>>>>>>>>>>>>>>>> nested emulation of the input to H(P,P) would be. Any
>>>>>>>>>>>>>>>>> failure to provide this basis for your damned lies will
>>>>>>>>>>>>>>>>> be considered direct admission that you know you are
>>>>>>>>>>>>>>>>> lying.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _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]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Well, I wopuld need to have the code for H to do that,
>>>>>>>>>>>>>>>> since that is PART of P.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It would begin as:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>      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
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is stipulated that you must show what the execution
>>>>>>>>>>>>> trace of the input to H(P,P) would be if H only simulated
>>>>>>>>>>>>> its input. You must show this for one simulation and one
>>>>>>>>>>>>> nested simulation. Failure to do this will be construed as
>>>>>>>>>>>>> a direct admission that you know you are lying.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, give me a copy of H to trace,
>>>>>>>>>>> You are required to provide a trace under the assumption that
>>>>>>>>>>> H(P,P) only does a pure x86 emulation of its input for the
>>>>>>>>>>> first emulation and the first nested emulation. Are you too
>>>>>>>>>>> stupid to understand this?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You obviously have an reading problem.
>>>>>>>>>>
>>>>>>>>>> I said, for that I need the code of H, as that is what needs
>>>>>>>>>> to be traced.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is "given" that this code only performs a pure x86
>>>>>>>>> emulation of its input (unless you have no idea what an x86
>>>>>>>>> emulation is) there is no reason to see that the code derives a
>>>>>>>>> pure x86 emulation of its input.
>>>>>>>>
>>>>>>>> The the trace of the emulation needs to show the actual steps of
>>>>>>>> emulationg the input, like I mentioned.
>>>>>>>>
>>>>>>> If I showed either the source-code of H or the execution trace of
>>>>>>> H people here would be so confused that I would never reach
>>>>>>> closure in 50 years. If they can't comprehend a 14 line execution
>>>>>>> trace then showing them much more than this would permanently
>>>>>>> scramble their brains.
>>>>>>
>>>>>> No, people wouldn't be confused,
>>>>>>
>>>>>
>>>>> That they don't understand that they don't need to see this
>>>>> conclusively proves that they have woefully inadequate technical
>>>>> skills to evaluate my work.
>>>>>
>>>>
>>>> Just shows you are lying.
>>>>
>>> I coined the term "ignorance squared" decades ago to account for the
>>> fact that people cannot possibly be directly aware of their own
>>> ignorance.
>>
>> You seem tobe a good example of that.
>>
>>>
>>> To be directly aware of their own ignorance requires them to contrast
>>> their ignorance with the knowledge that they are missing.
>>>
>>> Since they don't have this missing knowledge they cannot become
>>> directly aware that they are missing any knowledge. Their own
>>> ignorance is simply perceived as disagreement.
>>
>> So, what actual FACT do you think I am missing?
>  That the next level execution trace of the input to H(P,P) must be
> identical to the first level trace.
>

But you don't put difffernt levels of execution in a single trace.

THAT is the fact that I have pointed out and you refuse to comment on.

That make YOU statement illogical.

You confuse simulation with direct execution.

Yes, and UNCONDITIONAL simulation will give the same net results as a
direct exectution (when you take into account the indirection), but a
conditional simulation need not.

The "Sequence of states" that are passed through by the ACTUAL execution
hardware are different between a direct execution and a simulation, and
the trace needs to represent that difference.

You are just showing how little you understand about how computaters work.