On 8/27/2022 9:01 PM, Richard Damon wrote:
> On 8/27/22 9:36 PM, olcott wrote:
>> On 8/27/2022 8:24 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 9:02 PM, olcott wrote:
>>>> On 8/27/2022 7:47 PM, Richard Damon wrote:
>>>>> On 8/27/22 8:25 PM, olcott wrote:
>>>>>> On 8/27/2022 7:13 PM, Richard Damon wrote:
>>>>>>> On 8/27/22 7:53 PM, olcott wrote:
>>>>>>>> On 8/27/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>> On 8/27/22 7:25 PM, olcott wrote:
>>>>>>>>>> On 8/27/2022 5:59 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 8/27/22 6:25 PM, olcott wrote:
>>>>>>>>>>>> On 8/27/2022 4:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/27/22 5:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/27/2022 4:18 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/27/22 5:06 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/27/2022 2:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/27/22 3:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/27/2022 2:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/27/22 2:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Or just caught wordless because you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seeing you have no answer?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> He is just replying to change the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>> line to call you a troll and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to say that I am clueless about software
>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering. He really is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> fucktard who has got nothing of value to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> contribute.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> True.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> He has sealed his eternal legacy at a
>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Lying Idiot
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yep, he is just admitting that there is no
>>>>>>>>>>>>>>>>>>>>>>>>> truth in his statements he is admitting that he
>>>>>>>>>>>>>>>>>>>>>>>>> is wrong, but won't actually admit it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> By ignoring the people pointing out errors, he
>>>>>>>>>>>>>>>>>>>>>>>>> shows that he is only interested in himself and
>>>>>>>>>>>>>>>>>>>>>>>>> not what is actually true.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have pointed out all of the errors of all of
>>>>>>>>>>>>>>>>>>>>>>>> your rebuttals and instead of addressing these
>>>>>>>>>>>>>>>>>>>>>>>> errors you change the subject only to get back
>>>>>>>>>>>>>>>>>>>>>>>> to make these same mistakes again and again.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Really, point to an error I have made that you
>>>>>>>>>>>>>>>>>>>>>>> pointed out to any source other than "yourself"
>>>>>>>>>>>>>>>>>>>>>>> as grounds for me being wrong.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I don't think you KNOW HOW to actually deal with
>>>>>>>>>>>>>>>>>>>>>>> a rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Note, I DON'T change the subject, I go to the
>>>>>>>>>>>>>>>>>>>>>>> core of what you are talking about, and you
>>>>>>>>>>>>>>>>>>>>>>> object to that as I don't let you build up a bed
>>>>>>>>>>>>>>>>>>>>>>> of half truths to try to make you ideas seem
>>>>>>>>>>>>>>>>>>>>>>> possibly plausable.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Unless you ADMIT that you aren't talking about
>>>>>>>>>>>>>>>>>>>>>>> the Halting Theorm, all my comments are "On
>>>>>>>>>>>>>>>>>>>>>>> Topic" as I am just pointing out the basic
>>>>>>>>>>>>>>>>>>>>>>> definitions of the theory.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> YOU are the one that changes the subject.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> YOU FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS
>>>>>>>>>>>>>>>>>>>>>> WORDS*
>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>>> description always provides the actual behavior
>>>>>>>>>>>>>>>>>>>>>> specified by this machine description.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Correct, and the machine description includes ALL
>>>>>>>>>>>>>>>>>>>>> the code executed by the program, including all
>>>>>>>>>>>>>>>>>>>>> subroutines/function it calls.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS
>>>>>>>>>>>>>>>>>>>>>> WORDS*
>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>> correctly performs a partial simulation of its
>>>>>>>>>>>>>>>>>>>>>> input and the behavior of this partial simulation
>>>>>>>>>>>>>>>>>>>>>> correctly matches a correct non-halting behavior
>>>>>>>>>>>>>>>>>>>>>> pattern then the SHD halt decider can correctly
>>>>>>>>>>>>>>>>>>>>>> report non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS
>>>>>>>>>>>>>>>>>>>>>> WORDS*
>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this behavior pattern proves
>>>>>>>>>>>>>>>>>>>>>> that the simulated input to the SHD would never
>>>>>>>>>>>>>>>>>>>>>> stop running unless the SHD aborted its simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is a pattern that
>>>>>>>>>>>>>>>>>>>>> means that a correct and complete simulation could
>>>>>>>>>>>>>>>>>>>>> never stop after seeing that pattern, in any machine.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No it doesn't mean anything like that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You have a reference for that, or are you going to
>>>>>>>>>>>>>>>>>>> just use incorrect logic to try to make your point.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Example 01:
>>>>>>>>>>>>>>>>>>>> H0 correctly determines that Infinite_Loop() never
>>>>>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> [00001102](01)  55         push ebp
>>>>>>>>>>>>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>>>>>>>>>>>>>>>> [00001107](01)  5d         pop ebp
>>>>>>>>>>>>>>>>>>>> [00001108](01)  c3         ret
>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>>>> [00001192](01)  55         push ebp
>>>>>>>>>>>>>>>>>>>> [00001193](02)  8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001195](05)  6802110000 push 00001102
>>>>>>>>>>>>>>>>>>>> [0000119a](05)  e8d3fbffff call 00000d72
>>>>>>>>>>>>>>>>>>>> [0000119f](03)  83c404     add esp,+04
>>>>>>>>>>>>>>>>>>>> [000011a2](01)  50         push eax
>>>>>>>>>>>>>>>>>>>> [000011a3](05)  68a3040000 push 000004a3
>>>>>>>>>>>>>>>>>>>> [000011a8](05)  e845f3ffff call 000004f2
>>>>>>>>>>>>>>>>>>>> [000011ad](03)  83c408     add esp,+08
>>>>>>>>>>>>>>>>>>>> [000011b0](02)  33c0       xor eax,eax
>>>>>>>>>>>>>>>>>>>> [000011b2](01)  5d         pop ebp
>>>>>>>>>>>>>>>>>>>> [000011b3](01)  c3         ret
>>>>>>>>>>>>>>>>>>>> Size in bytes:(0034) [000011b3]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========
>>>>>>>>>>>>>>>>>>>> =============
>>>>>>>>>>>>>>>>>>>> [00001192][00101ef8][00000000] 55         push ebp
>>>>>>>>>>>>>>>>>>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>>>>>>>>>>>>>>>>>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>>>>>>>>>>>>>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>>>>>>>>>>>>>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>>>>>>>>>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>>>>>>>>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>   if (current->Simplified_Opcode == JMP)
>>>>>>>>>>>>>>>>>>>> // JMP
>>>>>>>>>>>>>>>>>>>>    if (current->Decode_Target <= current->Address)
>>>>>>>>>>>>>>>>>>>> // upward
>>>>>>>>>>>>>>>>>>>>     if (traced->Address == current->Decode_Target)
>>>>>>>>>>>>>>>>>>>> // to this address
>>>>>>>>>>>>>>>>>>>>      if (Conditional_Branch_Count == 0)
>>>>>>>>>>>>>>>>>>>> // no escape
>>>>>>>>>>>>>>>>>>>>       return 1;
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>>>>>>>>>>>>>>>>>>> [000011a2][00101ef4][00000000] 50         push eax
>>>>>>>>>>>>>>>>>>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>>>>>>>>>>>>>>>>>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>>>>>>>>>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>>>>>>>>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>>>>>>>>>>>>>>>>>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>>>>>>>>>>>>>>>>>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>>>>>>>>>>>>>>>>>>> [000011b3][00101f00][00000004] c3         ret
>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(554) == 8 Pages
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Halting is a property of the MACHINE, that is the
>>>>>>>>>>>>>>>>>>>>> MACHINE the input specified.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If halt deciders examined machines you would be
>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>> Halt deciders never examine machines.
>>>>>>>>>>>>>>>>>>>> Halt deciders always examine finite string machine
>>>>>>>>>>>>>>>>>>>> descriptions.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Isn't the finite string the machine code?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I thought you defined your "finite string" to BE the
>>>>>>>>>>>>>>>>>>> machine code for your machine.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because a simulating halt decider is a pure
>>>>>>>>>>>>>>>>>>>> simulator that has extra features added to it a
>>>>>>>>>>>>>>>>>>>> simulating halt decider that never aborts its
>>>>>>>>>>>>>>>>>>>> simulation is simply a pure simulator thus
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So does your H abort its simulation or not.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If it doesn't, then YES, it does a pure simulation
>>>>>>>>>>>>>>>>>>> and thus doesn't stop until the input reaches a final
>>>>>>>>>>>>>>>>>>> state, and thus never answers for a non-halting
>>>>>>>>>>>>>>>>>>> input, or
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> if it DOES, then it can't be the source of what a
>>>>>>>>>>>>>>>>>>> pure simulator does, since it isn't one.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Pleae show me a program that does BOTH be a pure
>>>>>>>>>>>>>>>>>>> simulator that simulates the non-halting input until
>>>>>>>>>>>>>>>>>>> it (never) reaches the final state, and also aborts
>>>>>>>>>>>>>>>>>>> its simulation to return the non-halting answer, at
>>>>>>>>>>>>>>>>>>> the same time.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the simulated input to
>>>>>>>>>>>>>>>>>>>> the SHD would
>>>>>>>>>>>>>>>>>>>> never stop running unless the SHD aborted its
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope. Proven wrong and illogical. You can't ask about
>>>>>>>>>>>>>>>>>>> behavior of a program (the SHD) that isn't part of
>>>>>>>>>>>>>>>>>>> the system. The "non-aborting" SHD is NOT the SHD, so
>>>>>>>>>>>>>>>>>>> you condition just doesn't occur.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A simulating halt decider
>>>>>>>>>>>>>>>>>> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT
>>>>>>>>>>>>>>>>>> WOULD BE IF IT NEVER ABORTED THE SIMULATION OF THIS INPUT
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then it isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A REAL Halt Decider decides on the behavior of the
>>>>>>>>>>>>>>>>> machine represented by its input, not the behavior of
>>>>>>>>>>>>>>>>> itself.
>>>>>>>>>>>>>>>> *Ah so that was my best wording*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (a) Every decider must compute the mapping from its
>>>>>>>>>>>>>>>> input finite string based on a semantic or syntactic
>>>>>>>>>>>>>>>> property of this finite string.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and the propert of this finite string is the
>>>>>>>>>>>>>>> behavior of UTM(P,d)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No not at all. The decider could be determining whether or
>>>>>>>>>>>>>> not an input string contains: "A".
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That would be deciding on a syntactic property.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A semantic property is something like Halting of UTM(P,d).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe you don't understand what you can ask a decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (b) A halt decider must compute the mapping from its
>>>>>>>>>>>>>>>> input finite string to an accept or reject state based
>>>>>>>>>>>>>>>> on the actual behavior of its actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and that is whether UTM(P,d) Halts or not.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When H correctly predicts that its input would never stop
>>>>>>>>>>>>>> running unless it aborts its simulation of this input it
>>>>>>>>>>>>>> is correctly predicting whether or not the pure (AKA UTM)
>>>>>>>>>>>>>> simulation of its input would stop running because H is a
>>>>>>>>>>>>>> pure (AKA UTM) simulator when it does not abort its
>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, Px(Px) is the simple counter example.
>>>>>>>>>>>>
>>>>>>>>>>>> You are contradicting yourself.
>>>>>>>>>>>>
>>>>>>>>>>>> The behavior of the input to H(P,P) when H does not aborts
>>>>>>>>>>>> its simulation of its input *is* the behavior of the pure
>>>>>>>>>>>> simulation of this input. That is proven on the basis of the
>>>>>>>>>>>> meaning of the words.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, but since H DOES abort its simulation, H is not a pure
>>>>>>>>>>> simulator,
>>>>>>>>>>
>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>
>>>>>>>>>> *A simulating halt decider that never aborts its simulation is
>>>>>>>>>> a UTM* thus when H correctly predicts that its simulated input
>>>>>>>>>> would never stop running unless H aborted this simulation it
>>>>>>>>>> has correctly predicted that a UTM simulation of this input
>>>>>>>>>> would never halt.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, if it NEVER abort.
>>>>>>>>>
>>>>>>>>
>>>>>>>> (a) The UTM simulation of the input is the measure of the actual
>>>>>>>> behavior of this input.
>>>>>>>>
>>>>>>>> (b) The behavior of the input to a SHD decider that never aborts
>>>>>>>> its simulation is the exact same behavior as a UTM simulation of
>>>>>>>> this input.
>>>>>>>>
>>>>>>>> (b) When a SHD decider correctly predicts that its input would
>>>>>>>> never stop running if it did not abort its simulation then it is
>>>>>>>> correctly predicting that the actual behavior of this input is
>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, the SHD in (c) can't be the SHD in (b) because the one in (c)
>>>>>>> aborts its simulation, while the one in (b) does not.
>>>>>>>
>>>>>>
>>>>>> (a) When a SHD correctly predicts that its simulated input would
>>>>>> never stop running unless it aborts its simulation
>>>>>>
>>>>>> (b) it is also predicting the behavior of the UTM simulation of
>>>>>> this same input
>>>>>>
>>>>>> (c) thus is also predicting the actual behavior of this input.
>>>>>>
>>>>>> (a)(b)(c) are merely different ways of saying the same thing.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> First, that gives you the behavior if H WAS a UTM, but that isn't
>>>>> what H is defined as, it is defined to be a Decider, so REQUIRED to
>>>>> answer in finite time, while a UTM doesn't.
>>>>>
>>>>> Of course, this only makes a difference if the input calls H, but
>>>>> in this case it does.
>>>>>
>>>>> Thus H is determining the wrong result.
>>>>>
>>>>> Second, the definition of Halting is NOT does the decider need to
>>>>> abort, but will the machine run to a final state.
>>>>>
>>>>
>>>> You are losing track of all the progress that we made: The
>>>> definition of halting is: A UTM simulation of this input reaches its
>>>> final state.
>>>
>>> Which only works because UTM simulaiton is BY DEFINITION recreating
>>> the behavior of the original machine.
>>>
>>> If it doesn't recreate the behavior, it ISN'T a UTM simulation.
>>
>> When we examine x86 machine code there is enough detail to
>> conclusively prove that the execution trace of the simulation of P
>> exactly matches the line-by-line behavior specified by the x86
>> source-code of P.
>>
>> Since this is the ultimate measure of a correct simulation anything
>> else that seems to disagree is refuted as incorrect.
>>
>
> Nope, becausee the x86 execution path of the program P actually goes
> through the function H.
>
> Your trace doesn't.
It does go through H, I just didn't show the 229 pages of trace of the
simulation of H when we already know that H is a simulating halt decider
thus we know that it does simulate P.

The complete trace (229 pages) of HH(Px,Px):
https://www.liarparadox.org/HH(Px,Px)_Complete_Trace.txt

--
Copyright 2022 Pete Olcott

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