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.
>
>

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,

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.
>
>

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.
>

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.
>
>

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.
>

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.
>
>

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.
>

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.

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.

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.
>

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.
>

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.

On 8/27/2022 9:33 PM, olcott wrote:
> 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
>