On 11/12/2022 2:01 PM, Richard Damon wrote:
> On 11/12/22 2:36 PM, olcott wrote:
>> On 11/12/2022 1:21 PM, Richard Damon wrote:
>>> On 11/12/22 2:04 PM, olcott wrote:
>>>> On 11/12/2022 12:57 PM, Richard Damon wrote:
>>>>> On 11/12/22 1:45 PM, olcott wrote:
>>>>>> On 11/12/2022 12:24 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 1:16 PM, olcott wrote:
>>>>>>>> On 11/12/2022 11:59 AM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 12:00 PM, olcott wrote:
>>>>>>>>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and I would have thought given your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intelligence you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> just mostly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> respond to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if
>>>>>>>>>>>>>>>>>>>>>>>>>>>> he has
>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders
>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>> around to point
>>>>>>>>>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>> know and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that he
>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors
>>>>>>>>>>>>>>>>>>>>>>>>>>>> become
>>>>>>>>>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as your
>>>>>>>>>>>>>>>>>>>>>>>>>>> only
>>>>>>>>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this,
>>>>>>>>>>>>>>>>>>>>>>>>>>> yet naive
>>>>>>>>>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>> universal Turing
>>>>>>>>>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H provides H with a correct basis
>>>>>>>>>>>>>>>>>>>>>>>>> for its
>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent
>>>>>>>>>>>>>>>>>>>>>>> the infinite
>>>>>>>>>>>>>>>>>>>>>>> execution of E is correct to report non-halting.
>>>>>>>>>>>>>>>>>>>>>>> No shell
>>>>>>>>>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT
>>>>>>>>>>>>>>>>>>>>>> because
>>>>>>>>>>>>>>>>>>>>>> the CORRECT simulation, as will the diret
>>>>>>>>>>>>>>>>>>>>>> exectuion, will
>>>>>>>>>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct
>>>>>>>>>>>>>>>>>>>>>> simulation, so any
>>>>>>>>>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The need to abort the simulation is due to the self
>>>>>>>>>>>>>>>>>>>>> reference
>>>>>>>>>>>>>>>>>>>>> category error present in the proof; what Olcott is
>>>>>>>>>>>>>>>>>>>>> getting
>>>>>>>>>>>>>>>>>>>>> wrong is the mapping of the need to abort the
>>>>>>>>>>>>>>>>>>>>> simulation to a
>>>>>>>>>>>>>>>>>>>>> halt decision of non-halting; it needs to instead
>>>>>>>>>>>>>>>>>>>>> be mapped to
>>>>>>>>>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> E just has a copy of the H that claim to be deciding
>>>>>>>>>>>>>>>>>>>> it, not a
>>>>>>>>>>>>>>>>>>>> "reference" to it. Turing Machines do not have the
>>>>>>>>>>>>>>>>>>>> power to
>>>>>>>>>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, if it isn't a self reference then it is
>>>>>>>>>>>>>>>>>>> infinite copies
>>>>>>>>>>>>>>>>>>> all the way down so is the same category error
>>>>>>>>>>>>>>>>>>> manifesting in a
>>>>>>>>>>>>>>>>>>> different way.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Only if the "decider" makes that happen, in which case
>>>>>>>>>>>>>>>>>> it isn't
>>>>>>>>>>>>>>>>>> actually a decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If we assume a prospective decider exists, then the
>>>>>>>>>>>>>>>>>> "Impossible"
>>>>>>>>>>>>>>>>>> program is simple to make from it, and is given one
>>>>>>>>>>>>>>>>>> copy of the
>>>>>>>>>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When run it makes a second copy of its description,
>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>> calls the decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> After that, it is the deciders job to make the
>>>>>>>>>>>>>>>>>> decision in finite
>>>>>>>>>>>>>>>>>> time, by whatever method it wants. If it gets stuck in
>>>>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The proof shows that what ever answer the decider does
>>>>>>>>>>>>>>>>>> give (if
>>>>>>>>>>>>>>>>>> it gives one) will be wrong, and thus the decider
>>>>>>>>>>>>>>>>>> doesn't meet
>>>>>>>>>>>>>>>>>> the requirements.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No "Self Reference" in sight there only a program
>>>>>>>>>>>>>>>>>> being given a
>>>>>>>>>>>>>>>>>> copy of something that just happens to be its own
>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The only place we get any form of "Reference", is when
>>>>>>>>>>>>>>>>>> we try to
>>>>>>>>>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge.
>>>>>>>>>>>>>>>>>> There the
>>>>>>>>>>>>>>>>>> effect of the Self-Reference just lets us see that the
>>>>>>>>>>>>>>>>>> task turns
>>>>>>>>>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are fractally wrong on all fronts: in the
>>>>>>>>>>>>>>>>> traditional halting
>>>>>>>>>>>>>>>>> problem proofs based on [Strachey 1965] the program is
>>>>>>>>>>>>>>>>> impossible
>>>>>>>>>>>>>>>>> not due to self reference or infinite copies but
>>>>>>>>>>>>>>>>> because the input
>>>>>>>>>>>>>>>>> tries to do the opposite of what the decider decides;
>>>>>>>>>>>>>>>>> the category
>>>>>>>>>>>>>>>>> error that I have identified is different: it is an
>>>>>>>>>>>>>>>>> error of self
>>>>>>>>>>>>>>>>> reference and/or infinite copies; it is an error
>>>>>>>>>>>>>>>>> related to the
>>>>>>>>>>>>>>>>> fact that the input references a decider rather than
>>>>>>>>>>>>>>>>> being related
>>>>>>>>>>>>>>>>> to what the input does with the decision result of a
>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>>>>>>>>>>> Strachey's program. The decider is SUPPOSED to be able
>>>>>>>>>>>>>>>> to handle
>>>>>>>>>>>>>>>> ANY input and answer in finite time, If an input causes
>>>>>>>>>>>>>>>> it to make
>>>>>>>>>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Turing Machine can ALWAYS be legally built based on
>>>>>>>>>>>>>>>> another Turing
>>>>>>>>>>>>>>>> Machine as a base. The only reason it wouldn't be
>>>>>>>>>>>>>>>> allowed is if H
>>>>>>>>>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a
>>>>>>>>>>>>>>>> category error
>>>>>>>>>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>>>>>>>>>>>> admitting that your H can't actually be a Turing
>>>>>>>>>>>>>>>> Machine, but must
>>>>>>>>>>>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>>>>>>>>>>>> requirement to be the needed decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In which case we get infinite turning machines all the
>>>>>>>>>>>>>>> way down: yet
>>>>>>>>>>>>>>> another manifestation of the category error I have
>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Where are infinite machines? There is ONE machine being
>>>>>>>>>>>>>> run, either H
>>>>>>>>>>>>>> or D, and it SIMULATING others, and if we get an infinite
>>>>>>>>>>>>>> sequence of
>>>>>>>>>>>>>> simulations we have just shown that H was defective
>>>>>>>>>>>>>> because it failed
>>>>>>>>>>>>>> to answer in finite time.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note, when we start H, there is exactly two machines
>>>>>>>>>>>>>> present in
>>>>>>>>>>>>>> representation on the tape, and two is much smaller than
>>>>>>>>>>>>>> infinity.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, if,
>>>>>>>>>>>>>
>>>>>>>>>>>>> a) H is a copy, and
>>>>>>>>>>>>> b) H is a Turing Machine, and
>>>>>>>>>>>>> c) D is an input into H, and
>>>>>>>>>>>>> d) D references H, and
>>>>>>>>>>>>> e) H references D,
>>>>>>>>>>>>>
>>>>>>>>>>>>> then (d) and (e) repeat ad infinitum so we get infinite
>>>>>>>>>>>>> Turing Machines
>>>>>>>>>>>>> all the way down: a manifestation of the category error I have
>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> The point is
>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> When H returns 0 to main() it is indicating
>>>>>>>>>>>>
>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except D is NOT correctly simulated by H, so that is a
>>>>>>>>>>> incorrect statement. When it is correctly simulated by
>>>>>>>>>>> something other than H, it will come to a final state,
>>>>>>>>>>> showing your statement is wrong.
>>>>>>>>>> In order for the simulation to actually be incorrect the
>>>>>>>>>> execution trace of the simulated E must diverge from the
>>>>>>>>>> behavior that the line-by-line x86 source-code of E specifies.
>>>>>>>>>
>>>>>>>>> Right, and since you simulation does NOT continue past the call
>>>>>>>>> to H, it is "incorrect" in the sense that the actual code does
>>>>>>>>> continue past that point, so it does not actually match the
>>>>>>>>> behavior of that machine.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The first seven lines of the execution trace of the simulated
>>>>>>>>>> E exactly match the behavior specified by the first seven
>>>>>>>>>> lines of the x86 source code of E. This conclusively proves
>>>>>>>>>> beyond all possible doubt that these first seven lines have
>>>>>>>>>> been simulated correctly.
>>>>>>>>>
>>>>>>>>> Right, so H has correctly done a PARTIAL simulation of its
>>>>>>>>> input, which does NOT prove the input is non-halting.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *H correctly determines that E never halts*
>>>>>>>>>>
>>>>>>>>>> void E(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>    H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _E()
>>>>>>>>>> [000019d2] 55             push ebp
>>>>>>>>>> [000019d3] 8bec           mov ebp,esp
>>>>>>>>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>>>>>>>>> [000019d8] 50             push eax
>>>>>>>>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>> [000019dc] 51             push ecx
>>>>>>>>>> [000019dd] e8b0f9ffff     call 00001392
>>>>>>>>>> [000019e2] 83c408         add esp,+08
>>>>>>>>>> [000019e5] 5d             pop ebp
>>>>>>>>>> [000019e6] c3             ret
>>>>>>>>>> Size in bytes:(0021) [000019e6]
>>>>>>>>>>
>>>>>>>>>> _main()
>>>>>>>>>> [000019f2] 55             push ebp
>>>>>>>>>> [000019f3] 8bec           mov ebp,esp
>>>>>>>>>> [000019f5] 68d2190000     push 000019d2
>>>>>>>>>> [000019fa] 68d2190000     push 000019d2
>>>>>>>>>> [000019ff] e88ef9ffff     call 00001392
>>>>>>>>>> [00001a04] 83c408         add esp,+08
>>>>>>>>>> [00001a07] 50             push eax
>>>>>>>>>> [00001a08] 6893060000     push 00000693
>>>>>>>>>> [00001a0d] e8a0ecffff     call 000006b2
>>>>>>>>>> [00001a12] 83c408         add esp,+08
>>>>>>>>>> [00001a15] 33c0           xor eax,eax
>>>>>>>>>> [00001a17] 5d             pop ebp
>>>>>>>>>> [00001a18] c3             ret
>>>>>>>>>> Size in bytes:(0039) [00001a18]
>>>>>>>>>>
>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>> [000019f2][00102a7c][00000000] 55         push ebp
>>>>>>>>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>>>>>>>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
>>>>>>>>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
>>>>>>>>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H
>>>>>>>>>>
>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>>> Address_of_H:1392
>>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax         //
>>>>>>>>>> push E
>>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         //
>>>>>>>>>> push E
>>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    //
>>>>>>>>>> call H
>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> H correctly reports that E correctly simulated by H cannot
>>>>>>>>>> possibly reach its own final state at machine address
>>>>>>>>>> [000019e6] and terminate normally in 1 to ∞ steps of correct
>>>>>>>>>> simulation.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So you are just admitting you don't understand the Halting
>>>>>>>>> Criteria.
>>>>>>>>>
>>>>>>>>> The fact that H stops its simulation before it gets to the end
>>>>>>>>> does NOT prove that the machine being simulated, or a correct
>>>>>>>>> and complete simultion of the input would be non-halting.
>>>>>>>> We must handle only one point at a time because you are easily
>>>>>>>> overwhelmed. You usually cannot even handle one point at a time
>>>>>>>> until this point is repeated 20 or more times.
>>>>>>>>
>>>>>>>> The fact that the line-by-line execution trace of the first
>>>>>>>> seven instructions E simulated by H exactly match the behavior
>>>>>>>> specified by the first seven instructions of the x86 source-code
>>>>>>>> of E conclusively proves that these first seven instructions are
>>>>>>>> simulated correctly.
>>>>>>>>
>>>>>>>
>>>>>>> No, that says that H did a correct PARTIAL simulation of the input.
>>>>>>
>>>>>> Yes that is correct now we can move on to the next point.
>>>>>>
>>>>>> void E(void (*x)())
>>>>>> {
>>>>>>    H(x, x);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>> }
>>>>>>
>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>> Address_of_H:1392
>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>> [000019d8][00112b10][000019d2] 50         push eax         // push E
>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         // push E
>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    // call H
>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>
>>>>>> We can see that the seventh instruction of E correctly simulated
>>>>>> by H would call H to simulate itself again.
>>>>>
>>>>> No, E calls H which will HALT DECIDER (by simulation) its input.
>>>> Try again this time don't use a noun as a verb gibberish.
>>>>
>>>
>>> So you can't understand that the call to H is supposed to Halt Decide
>>> its input?
>>>
>>> Minor typo, not gibberish like what you post that might follow
>>> correct syntax but has a lack of semantics.
>>>
>>> Do you agree that H(E,E) does return 0 when called?
>>
>> Again you leap ahead past the point at hand. Doing this makes sure
>> that the point at hand is never addressed and you false assumptions
>> continue.
>>
>> It is agreed that H does correctly simulate the first seven
>> instructions of E.
>>
>> The first seven instructions of E correctly simulated by H show that E
>> would call H to simulate itself again and that no instructions from
>> the beginning of E to its call to H can possibly prevent this from
>> repeating an unlimited number of times.
>>
>
> No, you characterize H incorrectly.
>
> I have explained this, and you snipped it, showing that you are
> INTENTIONALLY ignoring it, showing your illogic.
>
> it doesn't matter that the instruction that stops the loop is in H
> instead of E, it it there.

On 11/12/22 3:07 PM, olcott wrote:
> On 11/12/2022 2:01 PM, Richard Damon wrote:
>> On 11/12/22 2:36 PM, olcott wrote:
>>> On 11/12/2022 1:21 PM, Richard Damon wrote:
>>>> On 11/12/22 2:04 PM, olcott wrote:
>>>>> On 11/12/2022 12:57 PM, Richard Damon wrote:
>>>>>> On 11/12/22 1:45 PM, olcott wrote:
>>>>>>> On 11/12/2022 12:24 PM, Richard Damon wrote:
>>>>>>>> On 11/12/22 1:16 PM, olcott wrote:
>>>>>>>>> On 11/12/2022 11:59 AM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 12:00 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and I would have thought given your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intelligence you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just mostly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> respond to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if he has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> around to point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showing the Truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that he
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> your only
>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> yet naive
>>>>>>>>>>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>> a Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>> universal Turing
>>>>>>>>>>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H provides H with a correct basis
>>>>>>>>>>>>>>>>>>>>>>>>>> for its
>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent
>>>>>>>>>>>>>>>>>>>>>>>> the infinite
>>>>>>>>>>>>>>>>>>>>>>>> execution of E is correct to report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>> No shell
>>>>>>>>>>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Any H that does aborts its simulation is
>>>>>>>>>>>>>>>>>>>>>>> INCORRECT because
>>>>>>>>>>>>>>>>>>>>>>> the CORRECT simulation, as will the diret
>>>>>>>>>>>>>>>>>>>>>>> exectuion, will
>>>>>>>>>>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct
>>>>>>>>>>>>>>>>>>>>>>> simulation, so any
>>>>>>>>>>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The need to abort the simulation is due to the
>>>>>>>>>>>>>>>>>>>>>> self reference
>>>>>>>>>>>>>>>>>>>>>> category error present in the proof; what Olcott
>>>>>>>>>>>>>>>>>>>>>> is getting
>>>>>>>>>>>>>>>>>>>>>> wrong is the mapping of the need to abort the
>>>>>>>>>>>>>>>>>>>>>> simulation to a
>>>>>>>>>>>>>>>>>>>>>> halt decision of non-halting; it needs to instead
>>>>>>>>>>>>>>>>>>>>>> be mapped to
>>>>>>>>>>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> E just has a copy of the H that claim to be
>>>>>>>>>>>>>>>>>>>>> deciding it, not a
>>>>>>>>>>>>>>>>>>>>> "reference" to it. Turing Machines do not have the
>>>>>>>>>>>>>>>>>>>>> power to
>>>>>>>>>>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, if it isn't a self reference then it is
>>>>>>>>>>>>>>>>>>>> infinite copies
>>>>>>>>>>>>>>>>>>>> all the way down so is the same category error
>>>>>>>>>>>>>>>>>>>> manifesting in a
>>>>>>>>>>>>>>>>>>>> different way.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Only if the "decider" makes that happen, in which
>>>>>>>>>>>>>>>>>>> case it isn't
>>>>>>>>>>>>>>>>>>> actually a decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If we assume a prospective decider exists, then the
>>>>>>>>>>>>>>>>>>> "Impossible"
>>>>>>>>>>>>>>>>>>> program is simple to make from it, and is given one
>>>>>>>>>>>>>>>>>>> copy of the
>>>>>>>>>>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When run it makes a second copy of its description,
>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>> calls the decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> After that, it is the deciders job to make the
>>>>>>>>>>>>>>>>>>> decision in finite
>>>>>>>>>>>>>>>>>>> time, by whatever method it wants. If it gets stuck
>>>>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The proof shows that what ever answer the decider
>>>>>>>>>>>>>>>>>>> does give (if
>>>>>>>>>>>>>>>>>>> it gives one) will be wrong, and thus the decider
>>>>>>>>>>>>>>>>>>> doesn't meet
>>>>>>>>>>>>>>>>>>> the requirements.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No "Self Reference" in sight there only a program
>>>>>>>>>>>>>>>>>>> being given a
>>>>>>>>>>>>>>>>>>> copy of something that just happens to be its own
>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The only place we get any form of "Reference", is
>>>>>>>>>>>>>>>>>>> when we try to
>>>>>>>>>>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge.
>>>>>>>>>>>>>>>>>>> There the
>>>>>>>>>>>>>>>>>>> effect of the Self-Reference just lets us see that
>>>>>>>>>>>>>>>>>>> the task turns
>>>>>>>>>>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are fractally wrong on all fronts: in the
>>>>>>>>>>>>>>>>>> traditional halting
>>>>>>>>>>>>>>>>>> problem proofs based on [Strachey 1965] the program is
>>>>>>>>>>>>>>>>>> impossible
>>>>>>>>>>>>>>>>>> not due to self reference or infinite copies but
>>>>>>>>>>>>>>>>>> because the input
>>>>>>>>>>>>>>>>>> tries to do the opposite of what the decider decides;
>>>>>>>>>>>>>>>>>> the category
>>>>>>>>>>>>>>>>>> error that I have identified is different: it is an
>>>>>>>>>>>>>>>>>> error of self
>>>>>>>>>>>>>>>>>> reference and/or infinite copies; it is an error
>>>>>>>>>>>>>>>>>> related to the
>>>>>>>>>>>>>>>>>> fact that the input references a decider rather than
>>>>>>>>>>>>>>>>>> being related
>>>>>>>>>>>>>>>>>> to what the input does with the decision result of a
>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>>>>>>>>>>>> Strachey's program. The decider is SUPPOSED to be able
>>>>>>>>>>>>>>>>> to handle
>>>>>>>>>>>>>>>>> ANY input and answer in finite time, If an input causes
>>>>>>>>>>>>>>>>> it to make
>>>>>>>>>>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Turing Machine can ALWAYS be legally built based on
>>>>>>>>>>>>>>>>> another Turing
>>>>>>>>>>>>>>>>> Machine as a base. The only reason it wouldn't be
>>>>>>>>>>>>>>>>> allowed is if H
>>>>>>>>>>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a
>>>>>>>>>>>>>>>>> category error
>>>>>>>>>>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All your declaration of a "Category Error" here is
>>>>>>>>>>>>>>>>> doing is
>>>>>>>>>>>>>>>>> admitting that your H can't actually be a Turing
>>>>>>>>>>>>>>>>> Machine, but must
>>>>>>>>>>>>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>>>>>>>>>>>>> requirement to be the needed decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In which case we get infinite turning machines all the
>>>>>>>>>>>>>>>> way down: yet
>>>>>>>>>>>>>>>> another manifestation of the category error I have
>>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Where are infinite machines? There is ONE machine being
>>>>>>>>>>>>>>> run, either H
>>>>>>>>>>>>>>> or D, and it SIMULATING others, and if we get an infinite
>>>>>>>>>>>>>>> sequence of
>>>>>>>>>>>>>>> simulations we have just shown that H was defective
>>>>>>>>>>>>>>> because it failed
>>>>>>>>>>>>>>> to answer in finite time.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note, when we start H, there is exactly two machines
>>>>>>>>>>>>>>> present in
>>>>>>>>>>>>>>> representation on the tape, and two is much smaller than
>>>>>>>>>>>>>>> infinity.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, if,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> a) H is a copy, and
>>>>>>>>>>>>>> b) H is a Turing Machine, and
>>>>>>>>>>>>>> c) D is an input into H, and
>>>>>>>>>>>>>> d) D references H, and
>>>>>>>>>>>>>> e) H references D,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> then (d) and (e) repeat ad infinitum so we get infinite
>>>>>>>>>>>>>> Turing Machines
>>>>>>>>>>>>>> all the way down: a manifestation of the category error I
>>>>>>>>>>>>>> have
>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> The point is
>>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When H returns 0 to main() it is indicating
>>>>>>>>>>>>>
>>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except D is NOT correctly simulated by H, so that is a
>>>>>>>>>>>> incorrect statement. When it is correctly simulated by
>>>>>>>>>>>> something other than H, it will come to a final state,
>>>>>>>>>>>> showing your statement is wrong.
>>>>>>>>>>> In order for the simulation to actually be incorrect the
>>>>>>>>>>> execution trace of the simulated E must diverge from the
>>>>>>>>>>> behavior that the line-by-line x86 source-code of E specifies.
>>>>>>>>>>
>>>>>>>>>> Right, and since you simulation does NOT continue past the
>>>>>>>>>> call to H, it is "incorrect" in the sense that the actual code
>>>>>>>>>> does continue past that point, so it does not actually match
>>>>>>>>>> the behavior of that machine.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The first seven lines of the execution trace of the simulated
>>>>>>>>>>> E exactly match the behavior specified by the first seven
>>>>>>>>>>> lines of the x86 source code of E. This conclusively proves
>>>>>>>>>>> beyond all possible doubt that these first seven lines have
>>>>>>>>>>> been simulated correctly.
>>>>>>>>>>
>>>>>>>>>> Right, so H has correctly done a PARTIAL simulation of its
>>>>>>>>>> input, which does NOT prove the input is non-halting.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *H correctly determines that E never halts*
>>>>>>>>>>>
>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>    H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> _E()
>>>>>>>>>>> [000019d2] 55             push ebp
>>>>>>>>>>> [000019d3] 8bec           mov ebp,esp
>>>>>>>>>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>>>>>>>>>> [000019d8] 50             push eax
>>>>>>>>>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>>> [000019dc] 51             push ecx
>>>>>>>>>>> [000019dd] e8b0f9ffff     call 00001392
>>>>>>>>>>> [000019e2] 83c408         add esp,+08
>>>>>>>>>>> [000019e5] 5d             pop ebp
>>>>>>>>>>> [000019e6] c3             ret
>>>>>>>>>>> Size in bytes:(0021) [000019e6]
>>>>>>>>>>>
>>>>>>>>>>> _main()
>>>>>>>>>>> [000019f2] 55             push ebp
>>>>>>>>>>> [000019f3] 8bec           mov ebp,esp
>>>>>>>>>>> [000019f5] 68d2190000     push 000019d2
>>>>>>>>>>> [000019fa] 68d2190000     push 000019d2
>>>>>>>>>>> [000019ff] e88ef9ffff     call 00001392
>>>>>>>>>>> [00001a04] 83c408         add esp,+08
>>>>>>>>>>> [00001a07] 50             push eax
>>>>>>>>>>> [00001a08] 6893060000     push 00000693
>>>>>>>>>>> [00001a0d] e8a0ecffff     call 000006b2
>>>>>>>>>>> [00001a12] 83c408         add esp,+08
>>>>>>>>>>> [00001a15] 33c0           xor eax,eax
>>>>>>>>>>> [00001a17] 5d             pop ebp
>>>>>>>>>>> [00001a18] c3             ret
>>>>>>>>>>> Size in bytes:(0039) [00001a18]
>>>>>>>>>>>
>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>> [000019f2][00102a7c][00000000] 55         push ebp
>>>>>>>>>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>>>>>>>>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>> push E
>>>>>>>>>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>> push E
>>>>>>>>>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 //
>>>>>>>>>>> call H
>>>>>>>>>>>
>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>>>> Address_of_H:1392
>>>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax         //
>>>>>>>>>>> push E
>>>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         //
>>>>>>>>>>> push E
>>>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    //
>>>>>>>>>>> call H
>>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>
>>>>>>>>>>> H correctly reports that E correctly simulated by H cannot
>>>>>>>>>>> possibly reach its own final state at machine address
>>>>>>>>>>> [000019e6] and terminate normally in 1 to ∞ steps of correct
>>>>>>>>>>> simulation.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So you are just admitting you don't understand the Halting
>>>>>>>>>> Criteria.
>>>>>>>>>>
>>>>>>>>>> The fact that H stops its simulation before it gets to the end
>>>>>>>>>> does NOT prove that the machine being simulated, or a correct
>>>>>>>>>> and complete simultion of the input would be non-halting.
>>>>>>>>> We must handle only one point at a time because you are easily
>>>>>>>>> overwhelmed. You usually cannot even handle one point at a time
>>>>>>>>> until this point is repeated 20 or more times.
>>>>>>>>>
>>>>>>>>> The fact that the line-by-line execution trace of the first
>>>>>>>>> seven instructions E simulated by H exactly match the behavior
>>>>>>>>> specified by the first seven instructions of the x86
>>>>>>>>> source-code of E conclusively proves that these first seven
>>>>>>>>> instructions are simulated correctly.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, that says that H did a correct PARTIAL simulation of the input.
>>>>>>>
>>>>>>> Yes that is correct now we can move on to the next point.
>>>>>>>
>>>>>>> void E(void (*x)())
>>>>>>> {
>>>>>>>    H(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>> }
>>>>>>>
>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>> Address_of_H:1392
>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>> [000019d8][00112b10][000019d2] 50         push eax         // push E
>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         // push E
>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    // call H
>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>
>>>>>>> We can see that the seventh instruction of E correctly simulated
>>>>>>> by H would call H to simulate itself again.
>>>>>>
>>>>>> No, E calls H which will HALT DECIDER (by simulation) its input.
>>>>> Try again this time don't use a noun as a verb gibberish.
>>>>>
>>>>
>>>> So you can't understand that the call to H is supposed to Halt
>>>> Decide its input?
>>>>
>>>> Minor typo, not gibberish like what you post that might follow
>>>> correct syntax but has a lack of semantics.
>>>>
>>>> Do you agree that H(E,E) does return 0 when called?
>>>
>>> Again you leap ahead past the point at hand. Doing this makes sure
>>> that the point at hand is never addressed and you false assumptions
>>> continue.
>>>
>>> It is agreed that H does correctly simulate the first seven
>>> instructions of E.
>>>
>>> The first seven instructions of E correctly simulated by H show that
>>> E would call H to simulate itself again and that no instructions from
>>> the beginning of E to its call to H can possibly prevent this from
>>> repeating an unlimited number of times.
>>>
>>
>> No, you characterize H incorrectly.
>>
>> I have explained this, and you snipped it, showing that you are
>> INTENTIONALLY ignoring it, showing your illogic.
>>
>> it doesn't matter that the instruction that stops the loop is in H
>> instead of E, it it there.
>
> It is not a matter of stopping the recursive simulation. It is a matter
> of proof that E correctly simulated by H cannot reach its own final
> state and terminate normally thus cannot possibly halt.
>

On 11/12/2022 2:26 PM, Richard Damon wrote:
> On 11/12/22 3:07 PM, olcott wrote:
>> On 11/12/2022 2:01 PM, Richard Damon wrote:
>>> On 11/12/22 2:36 PM, olcott wrote:
>>>> On 11/12/2022 1:21 PM, Richard Damon wrote:
>>>>> On 11/12/22 2:04 PM, olcott wrote:
>>>>>> On 11/12/2022 12:57 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 1:45 PM, olcott wrote:
>>>>>>>> On 11/12/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 1:16 PM, olcott wrote:
>>>>>>>>>> On 11/12/2022 11:59 AM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 12:00 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and I would have thought given your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intelligence you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just mostly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> respond to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if he has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> around to point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showing the Truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that he
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> errors become
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this, yet naive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> a Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>> universal Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H provides H with a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> basis for its
>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent
>>>>>>>>>>>>>>>>>>>>>>>>> the infinite
>>>>>>>>>>>>>>>>>>>>>>>>> execution of E is correct to report
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting. No shell
>>>>>>>>>>>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Any H that does aborts its simulation is
>>>>>>>>>>>>>>>>>>>>>>>> INCORRECT because
>>>>>>>>>>>>>>>>>>>>>>>> the CORRECT simulation, as will the diret
>>>>>>>>>>>>>>>>>>>>>>>> exectuion, will
>>>>>>>>>>>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct
>>>>>>>>>>>>>>>>>>>>>>>> simulation, so any
>>>>>>>>>>>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The need to abort the simulation is due to the
>>>>>>>>>>>>>>>>>>>>>>> self reference
>>>>>>>>>>>>>>>>>>>>>>> category error present in the proof; what Olcott
>>>>>>>>>>>>>>>>>>>>>>> is getting
>>>>>>>>>>>>>>>>>>>>>>> wrong is the mapping of the need to abort the
>>>>>>>>>>>>>>>>>>>>>>> simulation to a
>>>>>>>>>>>>>>>>>>>>>>> halt decision of non-halting; it needs to instead
>>>>>>>>>>>>>>>>>>>>>>> be mapped to
>>>>>>>>>>>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> E just has a copy of the H that claim to be
>>>>>>>>>>>>>>>>>>>>>> deciding it, not a
>>>>>>>>>>>>>>>>>>>>>> "reference" to it. Turing Machines do not have the
>>>>>>>>>>>>>>>>>>>>>> power to
>>>>>>>>>>>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, if it isn't a self reference then it is
>>>>>>>>>>>>>>>>>>>>> infinite copies
>>>>>>>>>>>>>>>>>>>>> all the way down so is the same category error
>>>>>>>>>>>>>>>>>>>>> manifesting in a
>>>>>>>>>>>>>>>>>>>>> different way.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Only if the "decider" makes that happen, in which
>>>>>>>>>>>>>>>>>>>> case it isn't
>>>>>>>>>>>>>>>>>>>> actually a decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If we assume a prospective decider exists, then the
>>>>>>>>>>>>>>>>>>>> "Impossible"
>>>>>>>>>>>>>>>>>>>> program is simple to make from it, and is given one
>>>>>>>>>>>>>>>>>>>> copy of the
>>>>>>>>>>>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When run it makes a second copy of its description,
>>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>>> calls the decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> After that, it is the deciders job to make the
>>>>>>>>>>>>>>>>>>>> decision in finite
>>>>>>>>>>>>>>>>>>>> time, by whatever method it wants. If it gets stuck
>>>>>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The proof shows that what ever answer the decider
>>>>>>>>>>>>>>>>>>>> does give (if
>>>>>>>>>>>>>>>>>>>> it gives one) will be wrong, and thus the decider
>>>>>>>>>>>>>>>>>>>> doesn't meet
>>>>>>>>>>>>>>>>>>>> the requirements.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No "Self Reference" in sight there only a program
>>>>>>>>>>>>>>>>>>>> being given a
>>>>>>>>>>>>>>>>>>>> copy of something that just happens to be its own
>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The only place we get any form of "Reference", is
>>>>>>>>>>>>>>>>>>>> when we try to
>>>>>>>>>>>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the
>>>>>>>>>>>>>>>>>>>> challenge. There the
>>>>>>>>>>>>>>>>>>>> effect of the Self-Reference just lets us see that
>>>>>>>>>>>>>>>>>>>> the task turns
>>>>>>>>>>>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are fractally wrong on all fronts: in the
>>>>>>>>>>>>>>>>>>> traditional halting
>>>>>>>>>>>>>>>>>>> problem proofs based on [Strachey 1965] the program
>>>>>>>>>>>>>>>>>>> is impossible
>>>>>>>>>>>>>>>>>>> not due to self reference or infinite copies but
>>>>>>>>>>>>>>>>>>> because the input
>>>>>>>>>>>>>>>>>>> tries to do the opposite of what the decider decides;
>>>>>>>>>>>>>>>>>>> the category
>>>>>>>>>>>>>>>>>>> error that I have identified is different: it is an
>>>>>>>>>>>>>>>>>>> error of self
>>>>>>>>>>>>>>>>>>> reference and/or infinite copies; it is an error
>>>>>>>>>>>>>>>>>>> related to the
>>>>>>>>>>>>>>>>>>> fact that the input references a decider rather than
>>>>>>>>>>>>>>>>>>> being related
>>>>>>>>>>>>>>>>>>> to what the input does with the decision result of a
>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>>>>>>>>>>>>> Strachey's program. The decider is SUPPOSED to be able
>>>>>>>>>>>>>>>>>> to handle
>>>>>>>>>>>>>>>>>> ANY input and answer in finite time, If an input
>>>>>>>>>>>>>>>>>> causes it to make
>>>>>>>>>>>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Turing Machine can ALWAYS be legally built based on
>>>>>>>>>>>>>>>>>> another Turing
>>>>>>>>>>>>>>>>>> Machine as a base. The only reason it wouldn't be
>>>>>>>>>>>>>>>>>> allowed is if H
>>>>>>>>>>>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a
>>>>>>>>>>>>>>>>>> category error
>>>>>>>>>>>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> All your declaration of a "Category Error" here is
>>>>>>>>>>>>>>>>>> doing is
>>>>>>>>>>>>>>>>>> admitting that your H can't actually be a Turing
>>>>>>>>>>>>>>>>>> Machine, but must
>>>>>>>>>>>>>>>>>> be of a HIGHER order logic system, which means H fails
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> requirement to be the needed decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In which case we get infinite turning machines all the
>>>>>>>>>>>>>>>>> way down: yet
>>>>>>>>>>>>>>>>> another manifestation of the category error I have
>>>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Where are infinite machines? There is ONE machine being
>>>>>>>>>>>>>>>> run, either H
>>>>>>>>>>>>>>>> or D, and it SIMULATING others, and if we get an
>>>>>>>>>>>>>>>> infinite sequence of
>>>>>>>>>>>>>>>> simulations we have just shown that H was defective
>>>>>>>>>>>>>>>> because it failed
>>>>>>>>>>>>>>>> to answer in finite time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note, when we start H, there is exactly two machines
>>>>>>>>>>>>>>>> present in
>>>>>>>>>>>>>>>> representation on the tape, and two is much smaller than
>>>>>>>>>>>>>>>> infinity.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, if,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> a) H is a copy, and
>>>>>>>>>>>>>>> b) H is a Turing Machine, and
>>>>>>>>>>>>>>> c) D is an input into H, and
>>>>>>>>>>>>>>> d) D references H, and
>>>>>>>>>>>>>>> e) H references D,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> then (d) and (e) repeat ad infinitum so we get infinite
>>>>>>>>>>>>>>> Turing Machines
>>>>>>>>>>>>>>> all the way down: a manifestation of the category error I
>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The point is
>>>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When H returns 0 to main() it is indicating
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞ steps
>>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except D is NOT correctly simulated by H, so that is a
>>>>>>>>>>>>> incorrect statement. When it is correctly simulated by
>>>>>>>>>>>>> something other than H, it will come to a final state,
>>>>>>>>>>>>> showing your statement is wrong.
>>>>>>>>>>>> In order for the simulation to actually be incorrect the
>>>>>>>>>>>> execution trace of the simulated E must diverge from the
>>>>>>>>>>>> behavior that the line-by-line x86 source-code of E specifies.
>>>>>>>>>>>
>>>>>>>>>>> Right, and since you simulation does NOT continue past the
>>>>>>>>>>> call to H, it is "incorrect" in the sense that the actual
>>>>>>>>>>> code does continue past that point, so it does not actually
>>>>>>>>>>> match the behavior of that machine.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The first seven lines of the execution trace of the
>>>>>>>>>>>> simulated E exactly match the behavior specified by the
>>>>>>>>>>>> first seven lines of the x86 source code of E. This
>>>>>>>>>>>> conclusively proves beyond all possible doubt that these
>>>>>>>>>>>> first seven lines have been simulated correctly.
>>>>>>>>>>>
>>>>>>>>>>> Right, so H has correctly done a PARTIAL simulation of its
>>>>>>>>>>> input, which does NOT prove the input is non-halting.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *H correctly determines that E never halts*
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> _E()
>>>>>>>>>>>> [000019d2] 55             push ebp
>>>>>>>>>>>> [000019d3] 8bec           mov ebp,esp
>>>>>>>>>>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>>>>>>>>>>> [000019d8] 50             push eax
>>>>>>>>>>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>>>> [000019dc] 51             push ecx
>>>>>>>>>>>> [000019dd] e8b0f9ffff     call 00001392
>>>>>>>>>>>> [000019e2] 83c408         add esp,+08
>>>>>>>>>>>> [000019e5] 5d             pop ebp
>>>>>>>>>>>> [000019e6] c3             ret
>>>>>>>>>>>> Size in bytes:(0021) [000019e6]
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [000019f2] 55             push ebp
>>>>>>>>>>>> [000019f3] 8bec           mov ebp,esp
>>>>>>>>>>>> [000019f5] 68d2190000     push 000019d2
>>>>>>>>>>>> [000019fa] 68d2190000     push 000019d2
>>>>>>>>>>>> [000019ff] e88ef9ffff     call 00001392
>>>>>>>>>>>> [00001a04] 83c408         add esp,+08
>>>>>>>>>>>> [00001a07] 50             push eax
>>>>>>>>>>>> [00001a08] 6893060000     push 00000693
>>>>>>>>>>>> [00001a0d] e8a0ecffff     call 000006b2
>>>>>>>>>>>> [00001a12] 83c408         add esp,+08
>>>>>>>>>>>> [00001a15] 33c0           xor eax,eax
>>>>>>>>>>>> [00001a17] 5d             pop ebp
>>>>>>>>>>>> [00001a18] c3             ret
>>>>>>>>>>>> Size in bytes:(0039) [00001a18]
>>>>>>>>>>>>
>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>> [000019f2][00102a7c][00000000] 55         push ebp
>>>>>>>>>>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>>> push E
>>>>>>>>>>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>>> push E
>>>>>>>>>>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 //
>>>>>>>>>>>> call H
>>>>>>>>>>>>
>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>>>>> Address_of_H:1392
>>>>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax
>>>>>>>>>>>> // push E
>>>>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx
>>>>>>>>>>>> // push E
>>>>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392
>>>>>>>>>>>> // call H
>>>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> H correctly reports that E correctly simulated by H cannot
>>>>>>>>>>>> possibly reach its own final state at machine address
>>>>>>>>>>>> [000019e6] and terminate normally in 1 to ∞ steps of correct
>>>>>>>>>>>> simulation.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So you are just admitting you don't understand the Halting
>>>>>>>>>>> Criteria.
>>>>>>>>>>>
>>>>>>>>>>> The fact that H stops its simulation before it gets to the
>>>>>>>>>>> end does NOT prove that the machine being simulated, or a
>>>>>>>>>>> correct and complete simultion of the input would be
>>>>>>>>>>> non-halting.
>>>>>>>>>> We must handle only one point at a time because you are easily
>>>>>>>>>> overwhelmed. You usually cannot even handle one point at a
>>>>>>>>>> time until this point is repeated 20 or more times.
>>>>>>>>>>
>>>>>>>>>> The fact that the line-by-line execution trace of the first
>>>>>>>>>> seven instructions E simulated by H exactly match the behavior
>>>>>>>>>> specified by the first seven instructions of the x86
>>>>>>>>>> source-code of E conclusively proves that these first seven
>>>>>>>>>> instructions are simulated correctly.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, that says that H did a correct PARTIAL simulation of the
>>>>>>>>> input.
>>>>>>>>
>>>>>>>> Yes that is correct now we can move on to the next point.
>>>>>>>>
>>>>>>>> void E(void (*x)())
>>>>>>>> {
>>>>>>>>    H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>> }
>>>>>>>>
>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>> Address_of_H:1392
>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax         //
>>>>>>>> push E
>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         //
>>>>>>>> push E
>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    //
>>>>>>>> call H
>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>
>>>>>>>> We can see that the seventh instruction of E correctly simulated
>>>>>>>> by H would call H to simulate itself again.
>>>>>>>
>>>>>>> No, E calls H which will HALT DECIDER (by simulation) its input.
>>>>>> Try again this time don't use a noun as a verb gibberish.
>>>>>>
>>>>>
>>>>> So you can't understand that the call to H is supposed to Halt
>>>>> Decide its input?
>>>>>
>>>>> Minor typo, not gibberish like what you post that might follow
>>>>> correct syntax but has a lack of semantics.
>>>>>
>>>>> Do you agree that H(E,E) does return 0 when called?
>>>>
>>>> Again you leap ahead past the point at hand. Doing this makes sure
>>>> that the point at hand is never addressed and you false assumptions
>>>> continue.
>>>>
>>>> It is agreed that H does correctly simulate the first seven
>>>> instructions of E.
>>>>
>>>> The first seven instructions of E correctly simulated by H show that
>>>> E would call H to simulate itself again and that no instructions
>>>> from the beginning of E to its call to H can possibly prevent this
>>>> from repeating an unlimited number of times.
>>>>
>>>
>>> No, you characterize H incorrectly.
>>>
>>> I have explained this, and you snipped it, showing that you are
>>> INTENTIONALLY ignoring it, showing your illogic.
>>>
>>> it doesn't matter that the instruction that stops the loop is in H
>>> instead of E, it it there.
>>
>> It is not a matter of stopping the recursive simulation. It is a
>> matter of proof that E correctly simulated by H cannot reach its own
>> final state and terminate normally thus cannot possibly halt.
>>
>
> Except that isn't the requriement except by your strawman.
>
> The ACTUAL requriement is that the machine represented by the input
> directly executed, or by equivalence, the simulation of the input by a UTM.
Before we assess validity of the criteria you must first agree that this
possibly invalid criteria has been met.

Hello. My name is Ben and I am an Olcottaholic. It's been 176 days
since my last post.

Stay strong, Richard. ;-)

--
Ben.

On 11/12/22 3:35 PM, olcott wrote:
> On 11/12/2022 2:26 PM, Richard Damon wrote:
>> On 11/12/22 3:07 PM, olcott wrote:
>>> On 11/12/2022 2:01 PM, Richard Damon wrote:
>>>> On 11/12/22 2:36 PM, olcott wrote:
>>>>> On 11/12/2022 1:21 PM, Richard Damon wrote:
>>>>>> On 11/12/22 2:04 PM, olcott wrote:
>>>>>>> On 11/12/2022 12:57 PM, Richard Damon wrote:
>>>>>>>> On 11/12/22 1:45 PM, olcott wrote:
>>>>>>>>> On 11/12/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 1:16 PM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 11:59 AM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 12:00 PM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and I would have thought given your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intelligence you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just mostly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> respond to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if he has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> around to point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showing the Truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that he
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> errors become
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this, yet naive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> universal Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H provides H with a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis for its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Any H that does abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>> prevent the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>> execution of E is correct to report
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting. No shell
>>>>>>>>>>>>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Any H that does aborts its simulation is
>>>>>>>>>>>>>>>>>>>>>>>>> INCORRECT because
>>>>>>>>>>>>>>>>>>>>>>>>> the CORRECT simulation, as will the diret
>>>>>>>>>>>>>>>>>>>>>>>>> exectuion, will
>>>>>>>>>>>>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct
>>>>>>>>>>>>>>>>>>>>>>>>> simulation, so any
>>>>>>>>>>>>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The need to abort the simulation is due to the
>>>>>>>>>>>>>>>>>>>>>>>> self reference
>>>>>>>>>>>>>>>>>>>>>>>> category error present in the proof; what Olcott
>>>>>>>>>>>>>>>>>>>>>>>> is getting
>>>>>>>>>>>>>>>>>>>>>>>> wrong is the mapping of the need to abort the
>>>>>>>>>>>>>>>>>>>>>>>> simulation to a
>>>>>>>>>>>>>>>>>>>>>>>> halt decision of non-halting; it needs to
>>>>>>>>>>>>>>>>>>>>>>>> instead be mapped to
>>>>>>>>>>>>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> E just has a copy of the H that claim to be
>>>>>>>>>>>>>>>>>>>>>>> deciding it, not a
>>>>>>>>>>>>>>>>>>>>>>> "reference" to it. Turing Machines do not have
>>>>>>>>>>>>>>>>>>>>>>> the power to
>>>>>>>>>>>>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope, if it isn't a self reference then it is
>>>>>>>>>>>>>>>>>>>>>> infinite copies
>>>>>>>>>>>>>>>>>>>>>> all the way down so is the same category error
>>>>>>>>>>>>>>>>>>>>>> manifesting in a
>>>>>>>>>>>>>>>>>>>>>> different way.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Only if the "decider" makes that happen, in which
>>>>>>>>>>>>>>>>>>>>> case it isn't
>>>>>>>>>>>>>>>>>>>>> actually a decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If we assume a prospective decider exists, then the
>>>>>>>>>>>>>>>>>>>>> "Impossible"
>>>>>>>>>>>>>>>>>>>>> program is simple to make from it, and is given one
>>>>>>>>>>>>>>>>>>>>> copy of the
>>>>>>>>>>>>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When run it makes a second copy of its description,
>>>>>>>>>>>>>>>>>>>>> and then
>>>>>>>>>>>>>>>>>>>>> calls the decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> After that, it is the deciders job to make the
>>>>>>>>>>>>>>>>>>>>> decision in finite
>>>>>>>>>>>>>>>>>>>>> time, by whatever method it wants. If it gets stuck
>>>>>>>>>>>>>>>>>>>>> in your
>>>>>>>>>>>>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The proof shows that what ever answer the decider
>>>>>>>>>>>>>>>>>>>>> does give (if
>>>>>>>>>>>>>>>>>>>>> it gives one) will be wrong, and thus the decider
>>>>>>>>>>>>>>>>>>>>> doesn't meet
>>>>>>>>>>>>>>>>>>>>> the requirements.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No "Self Reference" in sight there only a program
>>>>>>>>>>>>>>>>>>>>> being given a
>>>>>>>>>>>>>>>>>>>>> copy of something that just happens to be its own
>>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The only place we get any form of "Reference", is
>>>>>>>>>>>>>>>>>>>>> when we try to
>>>>>>>>>>>>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the
>>>>>>>>>>>>>>>>>>>>> challenge. There the
>>>>>>>>>>>>>>>>>>>>> effect of the Self-Reference just lets us see that
>>>>>>>>>>>>>>>>>>>>> the task turns
>>>>>>>>>>>>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are fractally wrong on all fronts: in the
>>>>>>>>>>>>>>>>>>>> traditional halting
>>>>>>>>>>>>>>>>>>>> problem proofs based on [Strachey 1965] the program
>>>>>>>>>>>>>>>>>>>> is impossible
>>>>>>>>>>>>>>>>>>>> not due to self reference or infinite copies but
>>>>>>>>>>>>>>>>>>>> because the input
>>>>>>>>>>>>>>>>>>>> tries to do the opposite of what the decider
>>>>>>>>>>>>>>>>>>>> decides; the category
>>>>>>>>>>>>>>>>>>>> error that I have identified is different: it is an
>>>>>>>>>>>>>>>>>>>> error of self
>>>>>>>>>>>>>>>>>>>> reference and/or infinite copies; it is an error
>>>>>>>>>>>>>>>>>>>> related to the
>>>>>>>>>>>>>>>>>>>> fact that the input references a decider rather than
>>>>>>>>>>>>>>>>>>>> being related
>>>>>>>>>>>>>>>>>>>> to what the input does with the decision result of a
>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But the infinite copies is a error in the Decider,
>>>>>>>>>>>>>>>>>>> not in
>>>>>>>>>>>>>>>>>>> Strachey's program. The decider is SUPPOSED to be
>>>>>>>>>>>>>>>>>>> able to handle
>>>>>>>>>>>>>>>>>>> ANY input and answer in finite time, If an input
>>>>>>>>>>>>>>>>>>> causes it to make
>>>>>>>>>>>>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Turing Machine can ALWAYS be legally built based on
>>>>>>>>>>>>>>>>>>> another Turing
>>>>>>>>>>>>>>>>>>> Machine as a base. The only reason it wouldn't be
>>>>>>>>>>>>>>>>>>> allowed is if H
>>>>>>>>>>>>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a
>>>>>>>>>>>>>>>>>>> category error
>>>>>>>>>>>>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> All your declaration of a "Category Error" here is
>>>>>>>>>>>>>>>>>>> doing is
>>>>>>>>>>>>>>>>>>> admitting that your H can't actually be a Turing
>>>>>>>>>>>>>>>>>>> Machine, but must
>>>>>>>>>>>>>>>>>>> be of a HIGHER order logic system, which means H
>>>>>>>>>>>>>>>>>>> fails the
>>>>>>>>>>>>>>>>>>> requirement to be the needed decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In which case we get infinite turning machines all the
>>>>>>>>>>>>>>>>>> way down: yet
>>>>>>>>>>>>>>>>>> another manifestation of the category error I have
>>>>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Where are infinite machines? There is ONE machine being
>>>>>>>>>>>>>>>>> run, either H
>>>>>>>>>>>>>>>>> or D, and it SIMULATING others, and if we get an
>>>>>>>>>>>>>>>>> infinite sequence of
>>>>>>>>>>>>>>>>> simulations we have just shown that H was defective
>>>>>>>>>>>>>>>>> because it failed
>>>>>>>>>>>>>>>>> to answer in finite time.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note, when we start H, there is exactly two machines
>>>>>>>>>>>>>>>>> present in
>>>>>>>>>>>>>>>>> representation on the tape, and two is much smaller
>>>>>>>>>>>>>>>>> than infinity.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, if,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> a) H is a copy, and
>>>>>>>>>>>>>>>> b) H is a Turing Machine, and
>>>>>>>>>>>>>>>> c) D is an input into H, and
>>>>>>>>>>>>>>>> d) D references H, and
>>>>>>>>>>>>>>>> e) H references D,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> then (d) and (e) repeat ad infinitum so we get infinite
>>>>>>>>>>>>>>>> Turing Machines
>>>>>>>>>>>>>>>> all the way down: a manifestation of the category error
>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The point is
>>>>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When H returns 0 to main() it is indicating
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> that D correctly simulated by H would never reach its own
>>>>>>>>>>>>>>> last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except D is NOT correctly simulated by H, so that is a
>>>>>>>>>>>>>> incorrect statement. When it is correctly simulated by
>>>>>>>>>>>>>> something other than H, it will come to a final state,
>>>>>>>>>>>>>> showing your statement is wrong.
>>>>>>>>>>>>> In order for the simulation to actually be incorrect the
>>>>>>>>>>>>> execution trace of the simulated E must diverge from the
>>>>>>>>>>>>> behavior that the line-by-line x86 source-code of E specifies.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and since you simulation does NOT continue past the
>>>>>>>>>>>> call to H, it is "incorrect" in the sense that the actual
>>>>>>>>>>>> code does continue past that point, so it does not actually
>>>>>>>>>>>> match the behavior of that machine.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The first seven lines of the execution trace of the
>>>>>>>>>>>>> simulated E exactly match the behavior specified by the
>>>>>>>>>>>>> first seven lines of the x86 source code of E. This
>>>>>>>>>>>>> conclusively proves beyond all possible doubt that these
>>>>>>>>>>>>> first seven lines have been simulated correctly.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, so H has correctly done a PARTIAL simulation of its
>>>>>>>>>>>> input, which does NOT prove the input is non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *H correctly determines that E never halts*
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> _E()
>>>>>>>>>>>>> [000019d2] 55             push ebp
>>>>>>>>>>>>> [000019d3] 8bec           mov ebp,esp
>>>>>>>>>>>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>>>>>>>>>>>> [000019d8] 50             push eax
>>>>>>>>>>>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>>>>> [000019dc] 51             push ecx
>>>>>>>>>>>>> [000019dd] e8b0f9ffff     call 00001392
>>>>>>>>>>>>> [000019e2] 83c408         add esp,+08
>>>>>>>>>>>>> [000019e5] 5d             pop ebp
>>>>>>>>>>>>> [000019e6] c3             ret
>>>>>>>>>>>>> Size in bytes:(0021) [000019e6]
>>>>>>>>>>>>>
>>>>>>>>>>>>> _main()
>>>>>>>>>>>>> [000019f2] 55             push ebp
>>>>>>>>>>>>> [000019f3] 8bec           mov ebp,esp
>>>>>>>>>>>>> [000019f5] 68d2190000     push 000019d2
>>>>>>>>>>>>> [000019fa] 68d2190000     push 000019d2
>>>>>>>>>>>>> [000019ff] e88ef9ffff     call 00001392
>>>>>>>>>>>>> [00001a04] 83c408         add esp,+08
>>>>>>>>>>>>> [00001a07] 50             push eax
>>>>>>>>>>>>> [00001a08] 6893060000     push 00000693
>>>>>>>>>>>>> [00001a0d] e8a0ecffff     call 000006b2
>>>>>>>>>>>>> [00001a12] 83c408         add esp,+08
>>>>>>>>>>>>> [00001a15] 33c0           xor eax,eax
>>>>>>>>>>>>> [00001a17] 5d             pop ebp
>>>>>>>>>>>>> [00001a18] c3             ret
>>>>>>>>>>>>> Size in bytes:(0039) [00001a18]
>>>>>>>>>>>>>
>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>> [000019f2][00102a7c][00000000] 55         push ebp
>>>>>>>>>>>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>>>> push E
>>>>>>>>>>>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>>>> push E
>>>>>>>>>>>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 //
>>>>>>>>>>>>> call H
>>>>>>>>>>>>>
>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>>>>>> Address_of_H:1392
>>>>>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax // push E
>>>>>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx // push E
>>>>>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 //
>>>>>>>>>>>>> call H
>>>>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>
>>>>>>>>>>>>> H correctly reports that E correctly simulated by H cannot
>>>>>>>>>>>>> possibly reach its own final state at machine address
>>>>>>>>>>>>> [000019e6] and terminate normally in 1 to ∞ steps of
>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So you are just admitting you don't understand the Halting
>>>>>>>>>>>> Criteria.
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that H stops its simulation before it gets to the
>>>>>>>>>>>> end does NOT prove that the machine being simulated, or a
>>>>>>>>>>>> correct and complete simultion of the input would be
>>>>>>>>>>>> non-halting.
>>>>>>>>>>> We must handle only one point at a time because you are
>>>>>>>>>>> easily overwhelmed. You usually cannot even handle one point
>>>>>>>>>>> at a time until this point is repeated 20 or more times.
>>>>>>>>>>>
>>>>>>>>>>> The fact that the line-by-line execution trace of the first
>>>>>>>>>>> seven instructions E simulated by H exactly match the
>>>>>>>>>>> behavior specified by the first seven instructions of the x86
>>>>>>>>>>> source-code of E conclusively proves that these first seven
>>>>>>>>>>> instructions are simulated correctly.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, that says that H did a correct PARTIAL simulation of the
>>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> Yes that is correct now we can move on to the next point.
>>>>>>>>>
>>>>>>>>> void E(void (*x)())
>>>>>>>>> {
>>>>>>>>>    H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>> Address_of_H:1392
>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax         //
>>>>>>>>> push E
>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         //
>>>>>>>>> push E
>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    //
>>>>>>>>> call H
>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>
>>>>>>>>> We can see that the seventh instruction of E correctly
>>>>>>>>> simulated by H would call H to simulate itself again.
>>>>>>>>
>>>>>>>> No, E calls H which will HALT DECIDER (by simulation) its input.
>>>>>>> Try again this time don't use a noun as a verb gibberish.
>>>>>>>
>>>>>>
>>>>>> So you can't understand that the call to H is supposed to Halt
>>>>>> Decide its input?
>>>>>>
>>>>>> Minor typo, not gibberish like what you post that might follow
>>>>>> correct syntax but has a lack of semantics.
>>>>>>
>>>>>> Do you agree that H(E,E) does return 0 when called?
>>>>>
>>>>> Again you leap ahead past the point at hand. Doing this makes sure
>>>>> that the point at hand is never addressed and you false assumptions
>>>>> continue.
>>>>>
>>>>> It is agreed that H does correctly simulate the first seven
>>>>> instructions of E.
>>>>>
>>>>> The first seven instructions of E correctly simulated by H show
>>>>> that E would call H to simulate itself again and that no
>>>>> instructions from the beginning of E to its call to H can possibly
>>>>> prevent this from repeating an unlimited number of times.
>>>>>
>>>>
>>>> No, you characterize H incorrectly.
>>>>
>>>> I have explained this, and you snipped it, showing that you are
>>>> INTENTIONALLY ignoring it, showing your illogic.
>>>>
>>>> it doesn't matter that the instruction that stops the loop is in H
>>>> instead of E, it it there.
>>>
>>> It is not a matter of stopping the recursive simulation. It is a
>>> matter of proof that E correctly simulated by H cannot reach its own
>>> final state and terminate normally thus cannot possibly halt.
>>>
>>
>> Except that isn't the requriement except by your strawman.
>>
>> The ACTUAL requriement is that the machine represented by the input
>> directly executed, or by equivalence, the simulation of the input by a
>> UTM.
> Before we assess validity of the criteria you must first agree that this
> possibly invalid criteria has been met.
>

On 11/12/2022 3:28 PM, Richard Damon wrote:
> On 11/12/22 3:35 PM, olcott wrote:
>> On 11/12/2022 2:26 PM, Richard Damon wrote:
>>> On 11/12/22 3:07 PM, olcott wrote:
>>>> On 11/12/2022 2:01 PM, Richard Damon wrote:
>>>>> On 11/12/22 2:36 PM, olcott wrote:
>>>>>> On 11/12/2022 1:21 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 2:04 PM, olcott wrote:
>>>>>>>> On 11/12/2022 12:57 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 1:45 PM, olcott wrote:
>>>>>>>>>> On 11/12/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 1:16 PM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 11:59 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 12:00 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and I would have thought given your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intelligence you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> me, just mostly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> respond to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if he has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wanders into the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> around to point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I know and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> showing the Truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show that he
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> put his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> errors become
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this, yet naive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universal Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by H provides H with a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis for its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Any H that does abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of E is correct to report
>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting. No shell
>>>>>>>>>>>>>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Any H that does aborts its simulation is
>>>>>>>>>>>>>>>>>>>>>>>>>> INCORRECT because
>>>>>>>>>>>>>>>>>>>>>>>>>> the CORRECT simulation, as will the diret
>>>>>>>>>>>>>>>>>>>>>>>>>> exectuion, will
>>>>>>>>>>>>>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, so any
>>>>>>>>>>>>>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The need to abort the simulation is due to the
>>>>>>>>>>>>>>>>>>>>>>>>> self reference
>>>>>>>>>>>>>>>>>>>>>>>>> category error present in the proof; what
>>>>>>>>>>>>>>>>>>>>>>>>> Olcott is getting
>>>>>>>>>>>>>>>>>>>>>>>>> wrong is the mapping of the need to abort the
>>>>>>>>>>>>>>>>>>>>>>>>> simulation to a
>>>>>>>>>>>>>>>>>>>>>>>>> halt decision of non-halting; it needs to
>>>>>>>>>>>>>>>>>>>>>>>>> instead be mapped to
>>>>>>>>>>>>>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> E just has a copy of the H that claim to be
>>>>>>>>>>>>>>>>>>>>>>>> deciding it, not a
>>>>>>>>>>>>>>>>>>>>>>>> "reference" to it. Turing Machines do not have
>>>>>>>>>>>>>>>>>>>>>>>> the power to
>>>>>>>>>>>>>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope, if it isn't a self reference then it is
>>>>>>>>>>>>>>>>>>>>>>> infinite copies
>>>>>>>>>>>>>>>>>>>>>>> all the way down so is the same category error
>>>>>>>>>>>>>>>>>>>>>>> manifesting in a
>>>>>>>>>>>>>>>>>>>>>>> different way.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Only if the "decider" makes that happen, in which
>>>>>>>>>>>>>>>>>>>>>> case it isn't
>>>>>>>>>>>>>>>>>>>>>> actually a decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If we assume a prospective decider exists, then
>>>>>>>>>>>>>>>>>>>>>> the "Impossible"
>>>>>>>>>>>>>>>>>>>>>> program is simple to make from it, and is given
>>>>>>>>>>>>>>>>>>>>>> one copy of the
>>>>>>>>>>>>>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When run it makes a second copy of its
>>>>>>>>>>>>>>>>>>>>>> description, and then
>>>>>>>>>>>>>>>>>>>>>> calls the decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> After that, it is the deciders job to make the
>>>>>>>>>>>>>>>>>>>>>> decision in finite
>>>>>>>>>>>>>>>>>>>>>> time, by whatever method it wants. If it gets
>>>>>>>>>>>>>>>>>>>>>> stuck in your
>>>>>>>>>>>>>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The proof shows that what ever answer the decider
>>>>>>>>>>>>>>>>>>>>>> does give (if
>>>>>>>>>>>>>>>>>>>>>> it gives one) will be wrong, and thus the decider
>>>>>>>>>>>>>>>>>>>>>> doesn't meet
>>>>>>>>>>>>>>>>>>>>>> the requirements.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No "Self Reference" in sight there only a program
>>>>>>>>>>>>>>>>>>>>>> being given a
>>>>>>>>>>>>>>>>>>>>>> copy of something that just happens to be its own
>>>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The only place we get any form of "Reference", is
>>>>>>>>>>>>>>>>>>>>>> when we try to
>>>>>>>>>>>>>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the
>>>>>>>>>>>>>>>>>>>>>> challenge. There the
>>>>>>>>>>>>>>>>>>>>>> effect of the Self-Reference just lets us see that
>>>>>>>>>>>>>>>>>>>>>> the task turns
>>>>>>>>>>>>>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are fractally wrong on all fronts: in the
>>>>>>>>>>>>>>>>>>>>> traditional halting
>>>>>>>>>>>>>>>>>>>>> problem proofs based on [Strachey 1965] the program
>>>>>>>>>>>>>>>>>>>>> is impossible
>>>>>>>>>>>>>>>>>>>>> not due to self reference or infinite copies but
>>>>>>>>>>>>>>>>>>>>> because the input
>>>>>>>>>>>>>>>>>>>>> tries to do the opposite of what the decider
>>>>>>>>>>>>>>>>>>>>> decides; the category
>>>>>>>>>>>>>>>>>>>>> error that I have identified is different: it is an
>>>>>>>>>>>>>>>>>>>>> error of self
>>>>>>>>>>>>>>>>>>>>> reference and/or infinite copies; it is an error
>>>>>>>>>>>>>>>>>>>>> related to the
>>>>>>>>>>>>>>>>>>>>> fact that the input references a decider rather
>>>>>>>>>>>>>>>>>>>>> than being related
>>>>>>>>>>>>>>>>>>>>> to what the input does with the decision result of
>>>>>>>>>>>>>>>>>>>>> a decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But the infinite copies is a error in the Decider,
>>>>>>>>>>>>>>>>>>>> not in
>>>>>>>>>>>>>>>>>>>> Strachey's program. The decider is SUPPOSED to be
>>>>>>>>>>>>>>>>>>>> able to handle
>>>>>>>>>>>>>>>>>>>> ANY input and answer in finite time, If an input
>>>>>>>>>>>>>>>>>>>> causes it to make
>>>>>>>>>>>>>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Turing Machine can ALWAYS be legally built based on
>>>>>>>>>>>>>>>>>>>> another Turing
>>>>>>>>>>>>>>>>>>>> Machine as a base. The only reason it wouldn't be
>>>>>>>>>>>>>>>>>>>> allowed is if H
>>>>>>>>>>>>>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a
>>>>>>>>>>>>>>>>>>>> category error
>>>>>>>>>>>>>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> All your declaration of a "Category Error" here is
>>>>>>>>>>>>>>>>>>>> doing is
>>>>>>>>>>>>>>>>>>>> admitting that your H can't actually be a Turing
>>>>>>>>>>>>>>>>>>>> Machine, but must
>>>>>>>>>>>>>>>>>>>> be of a HIGHER order logic system, which means H
>>>>>>>>>>>>>>>>>>>> fails the
>>>>>>>>>>>>>>>>>>>> requirement to be the needed decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In which case we get infinite turning machines all
>>>>>>>>>>>>>>>>>>> the way down: yet
>>>>>>>>>>>>>>>>>>> another manifestation of the category error I have
>>>>>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Where are infinite machines? There is ONE machine
>>>>>>>>>>>>>>>>>> being run, either H
>>>>>>>>>>>>>>>>>> or D, and it SIMULATING others, and if we get an
>>>>>>>>>>>>>>>>>> infinite sequence of
>>>>>>>>>>>>>>>>>> simulations we have just shown that H was defective
>>>>>>>>>>>>>>>>>> because it failed
>>>>>>>>>>>>>>>>>> to answer in finite time.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note, when we start H, there is exactly two machines
>>>>>>>>>>>>>>>>>> present in
>>>>>>>>>>>>>>>>>> representation on the tape, and two is much smaller
>>>>>>>>>>>>>>>>>> than infinity.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, if,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> a) H is a copy, and
>>>>>>>>>>>>>>>>> b) H is a Turing Machine, and
>>>>>>>>>>>>>>>>> c) D is an input into H, and
>>>>>>>>>>>>>>>>> d) D references H, and
>>>>>>>>>>>>>>>>> e) H references D,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> then (d) and (e) repeat ad infinitum so we get infinite
>>>>>>>>>>>>>>>>> Turing Machines
>>>>>>>>>>>>>>>>> all the way down: a manifestation of the category error
>>>>>>>>>>>>>>>>> I have
>>>>>>>>>>>>>>>>> identified.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The point is
>>>>>>>>>>>>>>>> that D correctly simulated by H would never reach its
>>>>>>>>>>>>>>>> own last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When H returns 0 to main() it is indicating
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> that D correctly simulated by H would never reach its
>>>>>>>>>>>>>>>> own last instruction and terminate normally after 1 to ∞
>>>>>>>>>>>>>>>> steps of correct simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except D is NOT correctly simulated by H, so that is a
>>>>>>>>>>>>>>> incorrect statement. When it is correctly simulated by
>>>>>>>>>>>>>>> something other than H, it will come to a final state,
>>>>>>>>>>>>>>> showing your statement is wrong.
>>>>>>>>>>>>>> In order for the simulation to actually be incorrect the
>>>>>>>>>>>>>> execution trace of the simulated E must diverge from the
>>>>>>>>>>>>>> behavior that the line-by-line x86 source-code of E
>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and since you simulation does NOT continue past the
>>>>>>>>>>>>> call to H, it is "incorrect" in the sense that the actual
>>>>>>>>>>>>> code does continue past that point, so it does not actually
>>>>>>>>>>>>> match the behavior of that machine.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The first seven lines of the execution trace of the
>>>>>>>>>>>>>> simulated E exactly match the behavior specified by the
>>>>>>>>>>>>>> first seven lines of the x86 source code of E. This
>>>>>>>>>>>>>> conclusively proves beyond all possible doubt that these
>>>>>>>>>>>>>> first seven lines have been simulated correctly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, so H has correctly done a PARTIAL simulation of its
>>>>>>>>>>>>> input, which does NOT prove the input is non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *H correctly determines that E never halts*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _E()
>>>>>>>>>>>>>> [000019d2] 55             push ebp
>>>>>>>>>>>>>> [000019d3] 8bec           mov ebp,esp
>>>>>>>>>>>>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>>>>>>>>>>>>> [000019d8] 50             push eax
>>>>>>>>>>>>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000019dc] 51             push ecx
>>>>>>>>>>>>>> [000019dd] e8b0f9ffff     call 00001392
>>>>>>>>>>>>>> [000019e2] 83c408         add esp,+08
>>>>>>>>>>>>>> [000019e5] 5d             pop ebp
>>>>>>>>>>>>>> [000019e6] c3             ret
>>>>>>>>>>>>>> Size in bytes:(0021) [000019e6]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>> [000019f2] 55             push ebp
>>>>>>>>>>>>>> [000019f3] 8bec           mov ebp,esp
>>>>>>>>>>>>>> [000019f5] 68d2190000     push 000019d2
>>>>>>>>>>>>>> [000019fa] 68d2190000     push 000019d2
>>>>>>>>>>>>>> [000019ff] e88ef9ffff     call 00001392
>>>>>>>>>>>>>> [00001a04] 83c408         add esp,+08
>>>>>>>>>>>>>> [00001a07] 50             push eax
>>>>>>>>>>>>>> [00001a08] 6893060000     push 00000693
>>>>>>>>>>>>>> [00001a0d] e8a0ecffff     call 000006b2
>>>>>>>>>>>>>> [00001a12] 83c408         add esp,+08
>>>>>>>>>>>>>> [00001a15] 33c0           xor eax,eax
>>>>>>>>>>>>>> [00001a17] 5d             pop ebp
>>>>>>>>>>>>>> [00001a18] c3             ret
>>>>>>>>>>>>>> Size in bytes:(0039) [00001a18]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>> [000019f2][00102a7c][00000000] 55         push ebp
>>>>>>>>>>>>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>>>>> push E
>>>>>>>>>>>>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 //
>>>>>>>>>>>>>> push E
>>>>>>>>>>>>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 //
>>>>>>>>>>>>>> call H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>>>>>>> Address_of_H:1392
>>>>>>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax // push E
>>>>>>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx // push E
>>>>>>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 //
>>>>>>>>>>>>>> call H
>>>>>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation
>>>>>>>>>>>>>> Stopped
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H correctly reports that E correctly simulated by H cannot
>>>>>>>>>>>>>> possibly reach its own final state at machine address
>>>>>>>>>>>>>> [000019e6] and terminate normally in 1 to ∞ steps of
>>>>>>>>>>>>>> correct simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you are just admitting you don't understand the Halting
>>>>>>>>>>>>> Criteria.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that H stops its simulation before it gets to the
>>>>>>>>>>>>> end does NOT prove that the machine being simulated, or a
>>>>>>>>>>>>> correct and complete simultion of the input would be
>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>> We must handle only one point at a time because you are
>>>>>>>>>>>> easily overwhelmed. You usually cannot even handle one point
>>>>>>>>>>>> at a time until this point is repeated 20 or more times.
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that the line-by-line execution trace of the first
>>>>>>>>>>>> seven instructions E simulated by H exactly match the
>>>>>>>>>>>> behavior specified by the first seven instructions of the
>>>>>>>>>>>> x86 source-code of E conclusively proves that these first
>>>>>>>>>>>> seven instructions are simulated correctly.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, that says that H did a correct PARTIAL simulation of the
>>>>>>>>>>> input.
>>>>>>>>>>
>>>>>>>>>> Yes that is correct now we can move on to the next point.
>>>>>>>>>>
>>>>>>>>>> void E(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>    H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    Output("Input_Halts = ", H(E, E));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>>>>>>>>> Address_of_H:1392
>>>>>>>>>> [000019d2][00112b14][00112b18] 55         push ebp
>>>>>>>>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>>>>>>>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> [000019d8][00112b10][000019d2] 50         push eax         //
>>>>>>>>>> push E
>>>>>>>>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>> [000019dc][00112b0c][000019d2] 51         push ecx         //
>>>>>>>>>> push E
>>>>>>>>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    //
>>>>>>>>>> call H
>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> We can see that the seventh instruction of E correctly
>>>>>>>>>> simulated by H would call H to simulate itself again.
>>>>>>>>>
>>>>>>>>> No, E calls H which will HALT DECIDER (by simulation) its input.
>>>>>>>> Try again this time don't use a noun as a verb gibberish.
>>>>>>>>
>>>>>>>
>>>>>>> So you can't understand that the call to H is supposed to Halt
>>>>>>> Decide its input?
>>>>>>>
>>>>>>> Minor typo, not gibberish like what you post that might follow
>>>>>>> correct syntax but has a lack of semantics.
>>>>>>>
>>>>>>> Do you agree that H(E,E) does return 0 when called?
>>>>>>
>>>>>> Again you leap ahead past the point at hand. Doing this makes sure
>>>>>> that the point at hand is never addressed and you false
>>>>>> assumptions continue.
>>>>>>
>>>>>> It is agreed that H does correctly simulate the first seven
>>>>>> instructions of E.
>>>>>>
>>>>>> The first seven instructions of E correctly simulated by H show
>>>>>> that E would call H to simulate itself again and that no
>>>>>> instructions from the beginning of E to its call to H can possibly
>>>>>> prevent this from repeating an unlimited number of times.
>>>>>>
>>>>>
>>>>> No, you characterize H incorrectly.
>>>>>
>>>>> I have explained this, and you snipped it, showing that you are
>>>>> INTENTIONALLY ignoring it, showing your illogic.
>>>>>
>>>>> it doesn't matter that the instruction that stops the loop is in H
>>>>> instead of E, it it there.
>>>>
>>>> It is not a matter of stopping the recursive simulation. It is a
>>>> matter of proof that E correctly simulated by H cannot reach its own
>>>> final state and terminate normally thus cannot possibly halt.
>>>>
>>>
>>> Except that isn't the requriement except by your strawman.
>>>
>>> The ACTUAL requriement is that the machine represented by the input
>>> directly executed, or by equivalence, the simulation of the input by
>>> a UTM.
>> Before we assess validity of the criteria you must first agree that
>> this possibly invalid criteria has been met.
>>
>
> The criteria you state is illogical, because it asks about the behavior
> of something that doesn't happen. As such it can not be valid.
When I predict that it is not going to rain tomorrow and it does not
rain tomorrow them my prediction about something that doesn't happen is
correct.

On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
> Hello. My name is Ben and I am an Olcottaholic. It's been 176 days
> since my last post.
>
> Stay strong, Richard. ;-)
>

I made the essence of my work simple enough that only expert knowledge
of the C programming language is required. H simulates its input using
an x86 emulator.

void Infinite_Loop()
{ HERE: goto HERE;
}

It is an easily verified fact that Infinite_Loop correctly simulated by
H would never reach its own last instruction and terminate normally
after 1 to ∞ steps of correct simulation.

void E(void (*x)())
{ H(x, x);
}

It is an easily verified fact that E correctly simulated by H would
never reach its own last instruction and terminate normally after 1 to ∞
steps of correct simulation. E remains stuck in recursive simulation
until aborted.

When H returns 0 to main() it correctly predicts that E correctly
simulated by H would never reach its own last instruction (final state)
and terminate normally after 1 to ∞ of correct simulation.

--
Copyright 2022 Pete Olcott

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

On 11/12/22 5:04 PM, olcott wrote:
> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176 days
>> since my last post.
>>
>> Stay strong, Richard.  ;-)
>>
>
> I made the essence of my work simple enough that only expert knowledge
> of the C programming language is required. H simulates its input using
> an x86 emulator.
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> It is an easily verified fact that Infinite_Loop correctly simulated by
> H would never reach its own last instruction and terminate normally
> after 1 to ∞ steps of correct simulation.
>
> void E(void (*x)())
> {
>   H(x, x);
> }
>
> It is an easily verified fact that E correctly simulated by H would
> never reach its own last instruction and terminate normally after 1 to ∞
> steps of correct simulation. E remains stuck in recursive simulation
> until aborted.
>

Since E can NOT be correctly simulated by H, that is an illogical
statement.

PERIOD

You are baseing your logic on things that are immossible. You are
depending on the power of Fairy Dust Powered Unicorn Magic to give you
your answer.

H is a DEFINED machine, and it has NO capability to demonstrate if the
correct simulation of this input would reach a final statt as it stops
too soom.

Note, the correct simulation of this input DOES halt, so it is imposible
for H to have correctly predicited that its correct simulation would
never halt. IMPOSSIBLE.

> When H returns 0 to main() it correctly predicts that E correctly
> simulated by H would never reach its own last instruction (final state)
> and terminate normally after 1 to ∞ of correct simulation.
>

And is wrong, because it used unsound logic and illogical definions.

It also proves, because of the criteria you are using that it isn't a
Halt Decider, but just a POOP decider.

To b a Halt Decider, it needs to indicate if the program represented by
the input would halt, which it does, so the correct answer is Halting.

All this proves is that you are just a pathological lying bastard that
doesn't know a thing about what you are talking about.

On 11/12/2022 4:26 PM, Richard Damon wrote:
> On 11/12/22 5:04 PM, olcott wrote:
>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176 days
>>> since my last post.
>>>
>>> Stay strong, Richard.  ;-)
>>>
>>
>> I made the essence of my work simple enough that only expert knowledge
>> of the C programming language is required. H simulates its input using
>> an x86 emulator.
>>
>> void Infinite_Loop()
>> {
>>    HERE: goto HERE;
>> }
>>
>> It is an easily verified fact that Infinite_Loop correctly simulated
>> by H would never reach its own last instruction and terminate normally
>> after 1 to ∞ steps of correct simulation.
>>
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>> It is an easily verified fact that E correctly simulated by H would
>> never reach its own last instruction and terminate normally after 1 to
>> ∞ steps of correct simulation. E remains stuck in recursive simulation
>> until aborted.
>>
>
> Since E can NOT be correctly simulated by H, that is an illogical
> statement.
>

You must really have brain damage because you have been corrected on the
point many times. When H correctly simulates 1 to N steps of D, then one
to N steps of D are correctly simulated.

When someone asks if I have any money then any amount of money > 0
counts. It is not a lie for me to say yes when I have less than an
infinite amount of money.

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 11/12/22 5:33 PM, olcott wrote:
> On 11/12/2022 4:26 PM, Richard Damon wrote:
>> On 11/12/22 5:04 PM, olcott wrote:
>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176 days
>>>> since my last post.
>>>>
>>>> Stay strong, Richard.  ;-)
>>>>
>>>
>>> I made the essence of my work simple enough that only expert
>>> knowledge of the C programming language is required. H simulates its
>>> input using an x86 emulator.
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> It is an easily verified fact that Infinite_Loop correctly simulated
>>> by H would never reach its own last instruction and terminate
>>> normally after 1 to ∞ steps of correct simulation.
>>>
>>> void E(void (*x)())
>>> {
>>>    H(x, x);
>>> }
>>>
>>> It is an easily verified fact that E correctly simulated by H would
>>> never reach its own last instruction and terminate normally after 1
>>> to ∞ steps of correct simulation. E remains stuck in recursive
>>> simulation until aborted.
>>>
>>
>> Since E can NOT be correctly simulated by H, that is an illogical
>> statement.
>>
>
> You must really have brain damage because you have been corrected on the
> point many times. When H correctly simulates 1 to N steps of D, then one
> to N steps of D are correctly simulated.
>
> When someone asks if I have any money then any amount of money > 0
> counts. It is not a lie for me to say yes when I have less than an
> infinite amount of money.
>

So, how does a SINGLE H simulate this precise input for from 1 to an
infinte number of steps,

Or is the issue that you are ignoring the H that is part of the program
D when you do this, thus proving you don't understand the meaning of a
program/function in computation theoryy.

Since the definition of correct simulation from the defintion of a UTM
is that it generates the exact same final behavior as the direct
executution of the machine it has been given via the representation, and
even you have admitted the D(D) halts if H(D,D) returns 0, the ONLY
POSSIBLE results of correctly simulating this D(D) is Halting.

You just don't understand the meaning of the words you are using and
just assuming things you know nothing about.

Your resorting to irrelvnt questions just inhances that fact.

What does asking if something is greater than zero being true even if
less than infinitity?

That seems to imply that you don't understand what non-halting means,
likely due to your lack of understanding of things "infinite" or unbounded.

Non-Halting means that the machine runs for an UNBOUNDED number of
steps, that it will NEVER reach a Halting state no matter how long you
run it.

NO finite simulation can directly show that, as any finite simulation
for only N steps doesn't show that the machine won't stop for N+M steps
(for M > 0). To prove non-halting you actually do need to either DO an
infinte number of steps or use some operation (like induction) to prove
that it will never halt for an umbounded number of steps.

You don't do this.

And infact, you don't give your deciders the same input as you change
what H the D calls to be the decider you are testing, NOT the original
specific H that you claim gets the right answer. Thus you proof is just
a LIE.

I would say that YOU are the one that shows the brain damage, as you
have been pointed to the definitions but you insist that they can't be
correct, but you can't actually prove that they aren't, you just insist
that they can't be.

This show a serious EGO problem, and serious lack of cognative ability.

Sorry that you have wasted your last 18 years of life and are going to
leave with such a tarnished reputation.

I think inside you understand that, because you at least know that the
Journals will not accept your statements.

If you were the Genius that you think you are, you would be able to
somewhat easily figure out how to breakdown your ideas to something
simpler. When in fact, you are just foolish, and the fool is unable to
do that to his ideas, because at their core they really don't make
sense, and breaking them down just reveals there flaws.

On 11/12/2022 4:55 PM, Richard Damon wrote:
> On 11/12/22 5:33 PM, olcott wrote:
>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>> On 11/12/22 5:04 PM, olcott wrote:
>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176 days
>>>>> since my last post.
>>>>>
>>>>> Stay strong, Richard.  ;-)
>>>>>
>>>>
>>>> I made the essence of my work simple enough that only expert
>>>> knowledge of the C programming language is required. H simulates its
>>>> input using an x86 emulator.
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>>
>>>> It is an easily verified fact that Infinite_Loop correctly simulated
>>>> by H would never reach its own last instruction and terminate
>>>> normally after 1 to ∞ steps of correct simulation.
>>>>
>>>> void E(void (*x)())
>>>> {
>>>>    H(x, x);
>>>> }
>>>>
>>>> It is an easily verified fact that E correctly simulated by H would
>>>> never reach its own last instruction and terminate normally after 1
>>>> to ∞ steps of correct simulation. E remains stuck in recursive
>>>> simulation until aborted.
>>>>
>>>
>>> Since E can NOT be correctly simulated by H, that is an illogical
>>> statement.
>>>
>>
>> You must really have brain damage because you have been corrected on
>> the point many times. When H correctly simulates 1 to N steps of D,
>> then one to N steps of D are correctly simulated.
>>
>> When someone asks if I have any money then any amount of money > 0
>> counts. It is not a lie for me to say yes when I have less than an
>> infinite amount of money.
>>
>
> So, how does a SINGLE H simulate this precise input for from 1 to an
> infinte number of steps,
>
How do we know that every element of the infinite set of positive
integers > 5 is an element of the infinite set of integers > 3 ?

Once H correctly matches an infinite behavior pattern after N steps of
correct simulation then H knows that D correctly simulated by H will
never reach its final state and terminate normally in N to to ∞ steps of
correct simulation.

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 11/12/22 6:38 PM, olcott wrote:
> On 11/12/2022 4:55 PM, Richard Damon wrote:
>> On 11/12/22 5:33 PM, olcott wrote:
>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176 days
>>>>>> since my last post.
>>>>>>
>>>>>> Stay strong, Richard.  ;-)
>>>>>>
>>>>>
>>>>> I made the essence of my work simple enough that only expert
>>>>> knowledge of the C programming language is required. H simulates
>>>>> its input using an x86 emulator.
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>>    HERE: goto HERE;
>>>>> }
>>>>>
>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>> simulated by H would never reach its own last instruction and
>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>>
>>>>> void E(void (*x)())
>>>>> {
>>>>>    H(x, x);
>>>>> }
>>>>>
>>>>> It is an easily verified fact that E correctly simulated by H would
>>>>> never reach its own last instruction and terminate normally after 1
>>>>> to ∞ steps of correct simulation. E remains stuck in recursive
>>>>> simulation until aborted.
>>>>>
>>>>
>>>> Since E can NOT be correctly simulated by H, that is an illogical
>>>> statement.
>>>>
>>>
>>> You must really have brain damage because you have been corrected on
>>> the point many times. When H correctly simulates 1 to N steps of D,
>>> then one to N steps of D are correctly simulated.
>>>
>>> When someone asks if I have any money then any amount of money > 0
>>> counts. It is not a lie for me to say yes when I have less than an
>>> infinite amount of money.
>>>
>>
>> So, how does a SINGLE H simulate this precise input for from 1 to an
>> infinte number of steps,
>>
> How do we know that every element of the infinite set of positive
> integers > 5 is an element of the infinite set of integers > 3 ?
>
> Once H correctly matches an infinite behavior pattern after N steps of
> correct simulation then H knows that D correctly simulated by H will
> never reach its final state and terminate normally in N to to ∞ steps of
> correct simulation.
>

Because you can prove it.

Again you try to do proof by example, showing that you just don't
understand what you are doing.

Maybe some day you will be enlightened into what you have been doing wrong.

H can't prove the behavor of the D it is simulating because it needs to
take into account that H(D,D) WILL return if H takes the steps it needs
to in order to be a decider, and if it tries to wait for that to happen
it will NEVER return. Thus your template of decider can't prove a
correct answer for machines that call H with a copy of themselves.

You logic just makes H try to process the WRONG version of D, one that
uses a DIFFERENT version of H.

Your H just FAILS. It isn't that this is an "illegal" input, it is just
one that H can't handle,

SO YOU FAIL.

Note, this input IS decidable with a different decider, it just needs to
be one that waits long enough before deciding non-halting for this
machine to get to the point where it returns the 0. Of course the issue
is that if you build a new D1 with this decider, it won't get that new
D1 correctly,

On 11/12/2022 6:02 PM, Richard Damon wrote:
> On 11/12/22 6:38 PM, olcott wrote:
>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>> On 11/12/22 5:33 PM, olcott wrote:
>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176 days
>>>>>>> since my last post.
>>>>>>>
>>>>>>> Stay strong, Richard.  ;-)
>>>>>>>
>>>>>>
>>>>>> I made the essence of my work simple enough that only expert
>>>>>> knowledge of the C programming language is required. H simulates
>>>>>> its input using an x86 emulator.
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>>    HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>> simulated by H would never reach its own last instruction and
>>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>>>
>>>>>> void E(void (*x)())
>>>>>> {
>>>>>>    H(x, x);
>>>>>> }
>>>>>>
>>>>>> It is an easily verified fact that E correctly simulated by H
>>>>>> would never reach its own last instruction and terminate normally
>>>>>> after 1 to ∞ steps of correct simulation. E remains stuck in
>>>>>> recursive simulation until aborted.
>>>>>>
>>>>>
>>>>> Since E can NOT be correctly simulated by H, that is an illogical
>>>>> statement.
>>>>>
>>>>
>>>> You must really have brain damage because you have been corrected on
>>>> the point many times. When H correctly simulates 1 to N steps of D,
>>>> then one to N steps of D are correctly simulated.
>>>>
>>>> When someone asks if I have any money then any amount of money > 0
>>>> counts. It is not a lie for me to say yes when I have less than an
>>>> infinite amount of money.
>>>>
>>>
>>> So, how does a SINGLE H simulate this precise input for from 1 to an
>>> infinte number of steps,
>>>
>> How do we know that every element of the infinite set of positive
>> integers > 5 is an element of the infinite set of integers > 3 ?
>>
>> Once H correctly matches an infinite behavior pattern after N steps of
>> correct simulation then H knows that D correctly simulated by H will
>> never reach its final state and terminate normally in N to to ∞ steps
>> of correct simulation.
>>
>
> Because you can prove it.
>
> Again you try to do proof by example, showing that you just don't
> understand what you are doing.
>
> Maybe some day you will be enlightened into what you have been doing wrong.
>
> H can't prove the behavor of the D it is simulating because it needs to
> take into account that H(D,D) WILL return if H takes the steps it needs
void E(void (*x)())
{ H(x, x);
}

The simulated E never reaches its own final state whether or not H ever
aborts its simulation of E, thus E simulated by H is by definition not
halting.

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 11/12/22 8:31 PM, olcott wrote:
> On 11/12/2022 6:02 PM, Richard Damon wrote:
>> On 11/12/22 6:38 PM, olcott wrote:
>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176
>>>>>>>> days
>>>>>>>> since my last post.
>>>>>>>>
>>>>>>>> Stay strong, Richard.  ;-)
>>>>>>>>
>>>>>>>
>>>>>>> I made the essence of my work simple enough that only expert
>>>>>>> knowledge of the C programming language is required. H simulates
>>>>>>> its input using an x86 emulator.
>>>>>>>
>>>>>>> void Infinite_Loop()
>>>>>>> {
>>>>>>>    HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>>> simulated by H would never reach its own last instruction and
>>>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>>>>
>>>>>>> void E(void (*x)())
>>>>>>> {
>>>>>>>    H(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> It is an easily verified fact that E correctly simulated by H
>>>>>>> would never reach its own last instruction and terminate normally
>>>>>>> after 1 to ∞ steps of correct simulation. E remains stuck in
>>>>>>> recursive simulation until aborted.
>>>>>>>
>>>>>>
>>>>>> Since E can NOT be correctly simulated by H, that is an illogical
>>>>>> statement.
>>>>>>
>>>>>
>>>>> You must really have brain damage because you have been corrected
>>>>> on the point many times. When H correctly simulates 1 to N steps of
>>>>> D, then one to N steps of D are correctly simulated.
>>>>>
>>>>> When someone asks if I have any money then any amount of money > 0
>>>>> counts. It is not a lie for me to say yes when I have less than an
>>>>> infinite amount of money.
>>>>>
>>>>
>>>> So, how does a SINGLE H simulate this precise input for from 1 to an
>>>> infinte number of steps,
>>>>
>>> How do we know that every element of the infinite set of positive
>>> integers > 5 is an element of the infinite set of integers > 3 ?
>>>
>>> Once H correctly matches an infinite behavior pattern after N steps
>>> of correct simulation then H knows that D correctly simulated by H
>>> will never reach its final state and terminate normally in N to to ∞
>>> steps of correct simulation.
>>>
>>
>> Because you can prove it.
>>
>> Again you try to do proof by example, showing that you just don't
>> understand what you are doing.
>>
>> Maybe some day you will be enlightened into what you have been doing
>> wrong.
>>
>> H can't prove the behavor of the D it is simulating because it needs
>> to take into account that H(D,D) WILL return if H takes the steps it
>> needs
> void E(void (*x)())
> {
>   H(x, x);
> }
>
> The simulated E never reaches its own final state whether or not H ever
> aborts its simulation of E, thus E simulated by H is by definition not
> halting.
>

You say "Whether or not" which means you do not have a deinition for H,
because when you define H you need to define its behavior

This means you do NOT have a Computation Defined, and have been lying
about it for years that you know what you are doing.

You Have put forward a definition of what you seem to be claiming for
what the H that you claim to be a correct Halt Decider does, and that
one DOES abort its simulation, so of course the fact that that
simulation doesn't reach a final state means nothing about halting.

You also sometimes see to talk about another definition which you also
ERRONEOUSLY call H, which is just a blantent act of deception. Every
machine needs its own name within an analysis, reusing a name is just a
category error that renders your whole work worthless.

TO avoid that problem, we will call this alternate definition Hn (since
it doesn't abort), and then the E that calls it (again with our
incorrectr reusing of names) En.

We now have two TOTALLY distinct situations to look at (that you
decptively try to confuse by using the same name).

E(E) calling H(E,E) and En(En) calling Hn(En,En)

H(E,E) never does a complete simulation, so it has no evidence to say
that E(E) does not halt, and in fact the direct exectution of E(E) shows
it halts, and UTM(E,E) will also show that. SInce H(E,E) returns 0, it
is shown to be incorrect. More about why later.

The second case is En(En) and Hn(En,En). It does turn out the En(En)
will be a non-halting computation, so Hn would have been correct to
return 0, but becuase it never aborts it doesn't acutally do that, and
just fails to return an answer and so fails to be a decider.

Your error is that due to you deceptive (and incorrect) reuse of the
name, you actually seem to try to interpret H(E,E) as actuallh H(En,En).
It is a bit unclear on the mechanizism, because it falls into badly
stated logic, but it seems to be that H interpretes the call the H in E
as actully a call to Hn, which is essentially, and incorrect simulation.

IT does turn out the H(En,En) will correctly detect the En(En) is
non-halting, which you seem to try to use to claim that H(E,E) is
correct to give that same answer, because you H doesn't actually look at
the "H" that it calls and just assumes it must be Hn.

It also turns out that Hn(E,E) will correctly detect that E(E) does in
fact halt, and thus proves that H is WRONG about its answer,

Your logic where you claim that you you look at the simulation of 1 to
ininite steps has a fundamental flaw based on your nomencalture error.

You are actally talking about a whole set of deciders and their
impossible program, and each member of that set is a DIFFERENT machine,
so we need to give them each a DIFFERENT name, perhaps by giving them an
index i, so we have a set of Hi's each of which creates an Ei based on
it, (Here i is a variable index vs the constant subscriot n from above).

You then have the set of operations Hi(Ei,Ei) where you run a simulation
of "E' over the full range of steps, but in fact, there is only 1
simulation in that set that is the actual E, and every simulation done
in that set is of a DIFFERENT machine, so for every simulation you only
have a SINGLE number of steps done.

For some of them, Hi doesn't abort its simulation of Ei,Ei, and those
Hi's will show that Ei(Ei) is a non-halting computation, but
unfortunately for you, none of the return that answer, since the got
that proof by not aborting and running forever.

For the others, Hi DOES abort iss simulation of Ei,Ei and returns 0, but
unfortunately for you, we don't have in your set an unaborted simulation
of that input showing it to be non-halting, and in fact, if we DO run
UTM(Ei,Ei) for those cases, we find that the UTM will reach a final
state after the basic trace outline of Ei duplicates its input, goes
into Hi(Ei,Ei) which will in finite time return 0, and then Ei will halt.

So while, yes, it is true that no Hi(Ei,Ei) that does a complete
simulation ever saw the final state, none of those Hi ever gave an
answer to be correct about that.

You logic fall into the trap of you own making of confusing the
individual machines, and it seems like you mind doesn't understand that
this "set" you have defined doesn't produce *A* answer or even *A*
machine, but two distinct class of machine, both of which just are wrong
as Halt Deciders.

The depth you go to try to foist off this idea make it seems to be an
interntional ruse, but it could just be a total ignorance of how things
work, which also seems possible for you.

In short, your logic doesn't work, and the mere fact that you are trying
to use an alternate defition of Halting and reject the application of
the actual critera says you have just been lying about working on the
halting problem (or totally ignorantly off base) and none of you work
actually has any application to it,

On 11/12/2022 8:30 PM, Richard Damon wrote:
> On 11/12/22 8:31 PM, olcott wrote:
>> On 11/12/2022 6:02 PM, Richard Damon wrote:
>>> On 11/12/22 6:38 PM, olcott wrote:
>>>> On 11/12/2022 4:55 PM, Richard Damon wrote:
>>>>> On 11/12/22 5:33 PM, olcott wrote:
>>>>>> On 11/12/2022 4:26 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 5:04 PM, olcott wrote:
>>>>>>>> On 11/12/2022 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>> Hello.  My name is Ben and I am an Olcottaholic.  It's been 176
>>>>>>>>> days
>>>>>>>>> since my last post.
>>>>>>>>>
>>>>>>>>> Stay strong, Richard.  ;-)
>>>>>>>>>
>>>>>>>>
>>>>>>>> I made the essence of my work simple enough that only expert
>>>>>>>> knowledge of the C programming language is required. H simulates
>>>>>>>> its input using an x86 emulator.
>>>>>>>>
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>>    HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> It is an easily verified fact that Infinite_Loop correctly
>>>>>>>> simulated by H would never reach its own last instruction and
>>>>>>>> terminate normally after 1 to ∞ steps of correct simulation.
>>>>>>>>
>>>>>>>> void E(void (*x)())
>>>>>>>> {
>>>>>>>>    H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> It is an easily verified fact that E correctly simulated by H
>>>>>>>> would never reach its own last instruction and terminate
>>>>>>>> normally after 1 to ∞ steps of correct simulation. E remains
>>>>>>>> stuck in recursive simulation until aborted.
>>>>>>>>
>>>>>>>
>>>>>>> Since E can NOT be correctly simulated by H, that is an illogical
>>>>>>> statement.
>>>>>>>
>>>>>>
>>>>>> You must really have brain damage because you have been corrected
>>>>>> on the point many times. When H correctly simulates 1 to N steps
>>>>>> of D, then one to N steps of D are correctly simulated.
>>>>>>
>>>>>> When someone asks if I have any money then any amount of money > 0
>>>>>> counts. It is not a lie for me to say yes when I have less than an
>>>>>> infinite amount of money.
>>>>>>
>>>>>
>>>>> So, how does a SINGLE H simulate this precise input for from 1 to
>>>>> an infinte number of steps,
>>>>>
>>>> How do we know that every element of the infinite set of positive
>>>> integers > 5 is an element of the infinite set of integers > 3 ?
>>>>
>>>> Once H correctly matches an infinite behavior pattern after N steps
>>>> of correct simulation then H knows that D correctly simulated by H
>>>> will never reach its final state and terminate normally in N to to ∞
>>>> steps of correct simulation.
>>>>
>>>
>>> Because you can prove it.
>>>
>>> Again you try to do proof by example, showing that you just don't
>>> understand what you are doing.
>>>
>>> Maybe some day you will be enlightened into what you have been doing
>>> wrong.
>>>
>>> H can't prove the behavor of the D it is simulating because it needs
>>> to take into account that H(D,D) WILL return if H takes the steps it
>>> needs
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>> The simulated E never reaches its own final state whether or not H
>> ever aborts its simulation of E, thus E simulated by H is by
>> definition not halting.
>>
>
> You say "Whether or not" which means you do not have a deinition for H,
> because when you define H you need to define its behavior
In the same way that we know that every integer > 5 is also > 3
H correctly determines the halt status of D for every H/D pair such that
the H element of this H/D pair correctly simulates 1 to to ∞ steps of D.