On 11/13/2022 2:38 PM, Richard Damon wrote:
> On 11/13/22 2:49 PM, olcott wrote:
>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>> On 11/13/22 10:39 AM, olcott wrote:
>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> How does that apply?
>>>>>>>
>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>
>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>> Address_of_H:1383
>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      // push P
>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      // push P
>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>
>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>> the set of H/E pairs will never reach its final state and
>>>>>> terminate normally.
>>>>>> Why lie about this?
>>>>>>
>>>>>
>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>> eventually result in a return of 0 since this run just shopwed that
>>>>> H(P,P) returns 0.
>>>>>
>>>>> You have been told this many times and you ignore it.
>>>>
>>>> You told me that P simulated by H that never aborts its simulation
>>>> never stops running, thus from this we can correctly infer that no P
>>>> that has has had 1 to to ∞ steps correctly simulated by any H ever
>>>> reaches its own final state and terminates normally.
>>>>
>>>> Why do you use the strawman deception to lie?
>>>>
>>>
>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>
>> In other words you are saying that infinite loops specify a sequence
>> of configurations that terminate normally after a finite number of
>> steps of correct simulation.
>
> Nope, but the fact that you think that is what I said shows that you
> don't understand the material.
>
>>
>> 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.
>
> No one denied that, so this is just more of your Red Herring.
>
>>
>> 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.
>
> But that isn't the question, since the H you claim is correct doesn't
> correctly simulate the input since it aborts it.
>
> The H that this E is built on DOESN'T correctly simulate its input

On 11/13/22 3:51 PM, olcott wrote:
> On 11/13/2022 2:38 PM, Richard Damon wrote:
>> On 11/13/22 2:49 PM, olcott wrote:
>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> How does that apply?
>>>>>>>>
>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>
>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>>> Address_of_H:1383
>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      // push P
>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      // push P
>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>
>>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>>> the set of H/E pairs will never reach its final state and
>>>>>>> terminate normally.
>>>>>>> Why lie about this?
>>>>>>>
>>>>>>
>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>> that H(P,P) returns 0.
>>>>>>
>>>>>> You have been told this many times and you ignore it.
>>>>>
>>>>> You told me that P simulated by H that never aborts its simulation
>>>>> never stops running, thus from this we can correctly infer that no
>>>>> P that has has had 1 to to ∞ steps correctly simulated by any H
>>>>> ever reaches its own final state and terminates normally.
>>>>>
>>>>> Why do you use the strawman deception to lie?
>>>>>
>>>>
>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>
>>> In other words you are saying that infinite loops specify a sequence
>>> of configurations that terminate normally after a finite number of
>>> steps of correct simulation.
>>
>> Nope, but the fact that you think that is what I said shows that you
>> don't understand the material.
>>
>>>
>>> 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.
>>
>> No one denied that, so this is just more of your Red Herring.
>>
>>>
>>> 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.
>>
>> But that isn't the question, since the H you claim is correct doesn't
>> correctly simulate the input since it aborts it.
>>
>> The H that this E is built on DOESN'T correctly simulate its input
>
> _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]
>
> 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
>
> Since I already proved that H does correctly simulate E in that every
> line of the execution trace of E simulated by H exactly matches a
> corresponding line that the x86 source-code of E specifies, why do you
> lie about this?
>
No, H does a correct PARTIAL simulation of its input.

On 11/13/2022 3:02 PM, Richard Damon wrote:
> On 11/13/22 3:51 PM, olcott wrote:
>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>> On 11/13/22 2:49 PM, olcott wrote:
>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> How does that apply?
>>>>>>>>>
>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>
>>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>>>> Address_of_H:1383
>>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      // push P
>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      // push P
>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>
>>>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>>>> the set of H/E pairs will never reach its final state and
>>>>>>>> terminate normally.
>>>>>>>> Why lie about this?
>>>>>>>>
>>>>>>>
>>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>>> that H(P,P) returns 0.
>>>>>>>
>>>>>>> You have been told this many times and you ignore it.
>>>>>>
>>>>>> You told me that P simulated by H that never aborts its simulation
>>>>>> never stops running, thus from this we can correctly infer that no
>>>>>> P that has has had 1 to to ∞ steps correctly simulated by any H
>>>>>> ever reaches its own final state and terminates normally.
>>>>>>
>>>>>> Why do you use the strawman deception to lie?
>>>>>>
>>>>>
>>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>>
>>>> In other words you are saying that infinite loops specify a sequence
>>>> of configurations that terminate normally after a finite number of
>>>> steps of correct simulation.
>>>
>>> Nope, but the fact that you think that is what I said shows that you
>>> don't understand the material.
>>>
>>>>
>>>> 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.
>>>
>>> No one denied that, so this is just more of your Red Herring.
>>>
>>>>
>>>> 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.
>>>
>>> But that isn't the question, since the H you claim is correct doesn't
>>> correctly simulate the input since it aborts it.
>>>
>>> The H that this E is built on DOESN'T correctly simulate its input
>>
>> _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]
>>
>> 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
>>
>> Since I already proved that H does correctly simulate E in that every
>> line of the execution trace of E simulated by H exactly matches a
>> corresponding line that the x86 source-code of E specifies, why do you
>> lie about this?
>>
> No, H does a correct PARTIAL simulation of its input.
>
> When you mention that a correct simulation not reaching the end implies
> non-halting, that means it needs to be a COMPLETE siulation, so your
> statement is just a LIE.
>
> You are being INTENTIONALLY deceptive with shifting definition.
>
>
>> The first seven lines of E are proven to be correctly simulated by H
>> and also prove that E correctly simulated by every H that can possibly
>> exist would never reach its own final state and terminate normally.
>>
>>
>
> And the "Simulation" of the "CALL" instruction is INCORRECT.
>
The seventh line of E simulated by H is the seventh line of the x86
source-code of E.

On 11/13/22 4:16 PM, olcott wrote:
> On 11/13/2022 3:02 PM, Richard Damon wrote:
>> On 11/13/22 3:51 PM, olcott wrote:
>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> How does that apply?
>>>>>>>>>>
>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>
>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>>>>> Address_of_H:1383
>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      // push P
>>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      // push P
>>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>
>>>>>>>>> You and I both can see that D correctly simulated by every H of
>>>>>>>>> the set of H/E pairs will never reach its final state and
>>>>>>>>> terminate normally.
>>>>>>>>> Why lie about this?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>>>> that H(P,P) returns 0.
>>>>>>>>
>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>
>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>> simulation never stops running, thus from this we can correctly
>>>>>>> infer that no P that has has had 1 to to ∞ steps correctly
>>>>>>> simulated by any H ever reaches its own final state and
>>>>>>> terminates normally.
>>>>>>>
>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>
>>>>>>
>>>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>>>
>>>>> In other words you are saying that infinite loops specify a
>>>>> sequence of configurations that terminate normally after a finite
>>>>> number of steps of correct simulation.
>>>>
>>>> Nope, but the fact that you think that is what I said shows that you
>>>> don't understand the material.
>>>>
>>>>>
>>>>> 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.
>>>>
>>>> No one denied that, so this is just more of your Red Herring.
>>>>
>>>>>
>>>>> 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.
>>>>
>>>> But that isn't the question, since the H you claim is correct
>>>> doesn't correctly simulate the input since it aborts it.
>>>>
>>>> The H that this E is built on DOESN'T correctly simulate its input
>>>
>>> _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]
>>>
>>> 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
>>>
>>> Since I already proved that H does correctly simulate E in that every
>>> line of the execution trace of E simulated by H exactly matches a
>>> corresponding line that the x86 source-code of E specifies, why do
>>> you lie about this?
>>>
>> No, H does a correct PARTIAL simulation of its input.
>>
>> When you mention that a correct simulation not reaching the end
>> implies non-halting, that means it needs to be a COMPLETE siulation,
>> so your statement is just a LIE.
>>
>> You are being INTENTIONALLY deceptive with shifting definition.
>>
>>
>>> The first seven lines of E are proven to be correctly simulated by H
>>> and also prove that E correctly simulated by every H that can
>>> possibly exist would never reach its own final state and terminate
>>> normally.
>>>
>>>
>>
>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>
> The seventh line of E simulated by H is the seventh line of the x86
> source-code of E.
>
> The simulation can only be incorrect when the execution trace of the
> simulated E diverges from what the x86 source-code of E specifies, thus
> you lie again. Why do you insist on lying about easily verified facts?
>
>
And it does. How depends on which set of definitons you use.

On 11/13/2022 3:59 PM, Richard Damon wrote:
> On 11/13/22 4:16 PM, olcott wrote:
>> On 11/13/2022 3:02 PM, Richard Damon wrote:
>>> On 11/13/22 3:51 PM, olcott wrote:
>>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> How does that apply?
>>>>>>>>>>>
>>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>>
>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>>>>>> Address_of_H:1383
>>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      // push P
>>>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      // push P
>>>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 // call H
>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> You and I both can see that D correctly simulated by every H
>>>>>>>>>> of the set of H/E pairs will never reach its final state and
>>>>>>>>>> terminate normally.
>>>>>>>>>> Why lie about this?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, we know you are stupid and a liar because the call H must
>>>>>>>>> eventually result in a return of 0 since this run just shopwed
>>>>>>>>> that H(P,P) returns 0.
>>>>>>>>>
>>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>>
>>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>>> simulation never stops running, thus from this we can correctly
>>>>>>>> infer that no P that has has had 1 to to ∞ steps correctly
>>>>>>>> simulated by any H ever reaches its own final state and
>>>>>>>> terminates normally.
>>>>>>>>
>>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>>
>>>>>>>
>>>>>>> Right, but this H DOES abort its simulation, so that doesn't matter.
>>>>>>>
>>>>>> In other words you are saying that infinite loops specify a
>>>>>> sequence of configurations that terminate normally after a finite
>>>>>> number of steps of correct simulation.
>>>>>
>>>>> Nope, but the fact that you think that is what I said shows that
>>>>> you don't understand the material.
>>>>>
>>>>>>
>>>>>> 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.
>>>>>
>>>>> No one denied that, so this is just more of your Red Herring.
>>>>>
>>>>>>
>>>>>> 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.
>>>>>
>>>>> But that isn't the question, since the H you claim is correct
>>>>> doesn't correctly simulate the input since it aborts it.
>>>>>
>>>>> The H that this E is built on DOESN'T correctly simulate its input
>>>>
>>>> _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]
>>>>
>>>> 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
>>>>
>>>> Since I already proved that H does correctly simulate E in that
>>>> every line of the execution trace of E simulated by H exactly
>>>> matches a corresponding line that the x86 source-code of E
>>>> specifies, why do you lie about this?
>>>>
>>> No, H does a correct PARTIAL simulation of its input.
>>>
>>> When you mention that a correct simulation not reaching the end
>>> implies non-halting, that means it needs to be a COMPLETE siulation,
>>> so your statement is just a LIE.
>>>
>>> You are being INTENTIONALLY deceptive with shifting definition.
>>>
>>>
>>>> The first seven lines of E are proven to be correctly simulated by H
>>>> and also prove that E correctly simulated by every H that can
>>>> possibly exist would never reach its own final state and terminate
>>>> normally.
>>>>
>>>>
>>>
>>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>>
>> The seventh line of E simulated by H is the seventh line of the x86
>> source-code of E.
>>
>> The simulation can only be incorrect when the execution trace of the
>> simulated E diverges from what the x86 source-code of E specifies,
>> thus you lie again. Why do you insist on lying about easily verified
>> facts?
>>
>>
> And it does. How depends on which set of definitons you use.
>
> We can look at it one of two ways.
>
> THe first, is that since you are assserting that the failure of this
> trace to reach a final state shows that the program is non-halting, then
> the fact that in the actual program a "Call H" instruction continues
> into the function H, while in the simulation stops its simulation there.
>

On Sun, 13 Nov 2022 16:08:18 -0600
olcott <polcott2@gmail.com> wrote:

> On 11/13/2022 3:59 PM, Richard Damon wrote:
> > On 11/13/22 4:16 PM, olcott wrote:
> >> On 11/13/2022 3:02 PM, Richard Damon wrote:
> >>> On 11/13/22 3:51 PM, olcott wrote:
> >>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
> >>>>> On 11/13/22 2:49 PM, olcott wrote:
> >>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
> >>>>>>> On 11/13/22 10:39 AM, olcott wrote:
> >>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
> >>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
> >>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
> >>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
> >>>>>>>>>>>> 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.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> How does that apply?
> >>>>>>>>>>>
> >>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
> >>>>>>>>>>>
> >>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
> >>>>>>>>>> Address_of_H:1383
> >>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
> >>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
> >>>>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
> >>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
> >>>>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      //
> >>>>>>>>>> push P [0000199b][0015d4b5][00001993] 8b4d08     mov
> >>>>>>>>>> ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51
> >>>>>>>>>> push ecx      // push P [0000199f][0015d4ad][000019a4]
> >>>>>>>>>> e8dff9ffff call 00001383 // call H H: Infinitely Recursive
> >>>>>>>>>> Simulation Detected Simulation Stopped
> >>>>>>>>>>
> >>>>>>>>>> You and I both can see that D correctly simulated by every
> >>>>>>>>>> H of the set of H/E pairs will never reach its final state
> >>>>>>>>>> and terminate normally.
> >>>>>>>>>> Why lie about this?
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> Nope, we know you are stupid and a liar because the call H
> >>>>>>>>> must eventually result in a return of 0 since this run just
> >>>>>>>>> shopwed that H(P,P) returns 0.
> >>>>>>>>>
> >>>>>>>>> You have been told this many times and you ignore it.
> >>>>>>>>
> >>>>>>>> You told me that P simulated by H that never aborts its
> >>>>>>>> simulation never stops running, thus from this we can
> >>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
> >>>>>>>> correctly simulated by any H ever reaches its own final
> >>>>>>>> state and terminates normally.
> >>>>>>>>
> >>>>>>>> Why do you use the strawman deception to lie?
> >>>>>>>>
> >>>>>>>
> >>>>>>> Right, but this H DOES abort its simulation, so that doesn't
> >>>>>>> matter.
> >>>>>> In other words you are saying that infinite loops specify a
> >>>>>> sequence of configurations that terminate normally after a
> >>>>>> finite number of steps of correct simulation.
> >>>>>
> >>>>> Nope, but the fact that you think that is what I said shows
> >>>>> that you don't understand the material.
> >>>>>
> >>>>>>
> >>>>>> 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.
> >>>>>
> >>>>> No one denied that, so this is just more of your Red Herring.
> >>>>>
> >>>>>>
> >>>>>> 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.
> >>>>>
> >>>>> But that isn't the question, since the H you claim is correct
> >>>>> doesn't correctly simulate the input since it aborts it.
> >>>>>
> >>>>> The H that this E is built on DOESN'T correctly simulate its
> >>>>> input
> >>>>
> >>>> _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]
> >>>>
> >>>> 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
> >>>>
> >>>> Since I already proved that H does correctly simulate E in that
> >>>> every line of the execution trace of E simulated by H exactly
> >>>> matches a corresponding line that the x86 source-code of E
> >>>> specifies, why do you lie about this?
> >>>>
> >>> No, H does a correct PARTIAL simulation of its input.
> >>>
> >>> When you mention that a correct simulation not reaching the end
> >>> implies non-halting, that means it needs to be a COMPLETE
> >>> siulation, so your statement is just a LIE.
> >>>
> >>> You are being INTENTIONALLY deceptive with shifting definition.
> >>>
> >>>
> >>>> The first seven lines of E are proven to be correctly simulated
> >>>> by H and also prove that E correctly simulated by every H that
> >>>> can possibly exist would never reach its own final state and
> >>>> terminate normally.
> >>>>
> >>>>
> >>>
> >>> And the "Simulation" of the "CALL" instruction is INCORRECT.
> >>>
> >> The seventh line of E simulated by H is the seventh line of the
> >> x86 source-code of E.
> >>
> >> The simulation can only be incorrect when the execution trace of
> >> the simulated E diverges from what the x86 source-code of E
> >> specifies, thus you lie again. Why do you insist on lying about
> >> easily verified facts?
> >>
> >>
> > And it does. How depends on which set of definitons you use.
> >
> > We can look at it one of two ways.
> >
> > THe first, is that since you are assserting that the failure of
> > this trace to reach a final state shows that the program is
> > non-halting, then the fact that in the actual program a "Call H"
> > instruction continues into the function H, while in the simulation
> > stops its simulation there.
>
> int main() { H(D,D); } D simulated by H never stops running unless
> aborted and never halts: (reaches its own final state and terminates
> normally) whether aborted or not. Halt Deciders only report on the
> behavior of their inputs thus no strawman deception about the
> behavior of a non-input is any rebuttal at all.
>

On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
> On Sun, 13 Nov 2022 16:08:18 -0600
> olcott <polc...@gmail.com> wrote:
>
> > On 11/13/2022 3:59 PM, Richard Damon wrote:
> > > On 11/13/22 4:16 PM, olcott wrote:
> > >> On 11/13/2022 3:02 PM, Richard Damon wrote:
> > >>> On 11/13/22 3:51 PM, olcott wrote:
> > >>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
> > >>>>> On 11/13/22 2:49 PM, olcott wrote:
> > >>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
> > >>>>>>> On 11/13/22 10:39 AM, olcott wrote:
> > >>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
> > >>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
> > >>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
> > >>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
> > >>>>>>>>>>>> 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.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> How does that apply?
> > >>>>>>>>>>>
> > >>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
> > >>>>>>>>>>>
> > >>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
> > >>>>>>>>>> Address_of_H:1383
> > >>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
> > >>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
> > >>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
> > >>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
> > >>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax //
> > >>>>>>>>>> push P [0000199b][0015d4b5][00001993] 8b4d08 mov
> > >>>>>>>>>> ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51
> > >>>>>>>>>> push ecx // push P [0000199f][0015d4ad][000019a4]
> > >>>>>>>>>> e8dff9ffff call 00001383 // call H H: Infinitely Recursive
> > >>>>>>>>>> Simulation Detected Simulation Stopped
> > >>>>>>>>>>
> > >>>>>>>>>> You and I both can see that D correctly simulated by every
> > >>>>>>>>>> H of the set of H/E pairs will never reach its final state
> > >>>>>>>>>> and terminate normally.
> > >>>>>>>>>> Why lie about this?
> > >>>>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>> Nope, we know you are stupid and a liar because the call H
> > >>>>>>>>> must eventually result in a return of 0 since this run just
> > >>>>>>>>> shopwed that H(P,P) returns 0.
> > >>>>>>>>>
> > >>>>>>>>> You have been told this many times and you ignore it.
> > >>>>>>>>
> > >>>>>>>> You told me that P simulated by H that never aborts its
> > >>>>>>>> simulation never stops running, thus from this we can
> > >>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
> > >>>>>>>> correctly simulated by any H ever reaches its own final
> > >>>>>>>> state and terminates normally.
> > >>>>>>>>
> > >>>>>>>> Why do you use the strawman deception to lie?
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>> Right, but this H DOES abort its simulation, so that doesn't
> > >>>>>>> matter.
> > >>>>>> In other words you are saying that infinite loops specify a
> > >>>>>> sequence of configurations that terminate normally after a
> > >>>>>> finite number of steps of correct simulation.
> > >>>>>
> > >>>>> Nope, but the fact that you think that is what I said shows
> > >>>>> that you don't understand the material.
> > >>>>>
> > >>>>>>
> > >>>>>> 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.
> > >>>>>
> > >>>>> No one denied that, so this is just more of your Red Herring.
> > >>>>>
> > >>>>>>
> > >>>>>> 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.
> > >>>>>
> > >>>>> But that isn't the question, since the H you claim is correct
> > >>>>> doesn't correctly simulate the input since it aborts it.
> > >>>>>
> > >>>>> The H that this E is built on DOESN'T correctly simulate its
> > >>>>> input
> > >>>>
> > >>>> _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]
> > >>>>
> > >>>> 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
> > >>>>
> > >>>> Since I already proved that H does correctly simulate E in that
> > >>>> every line of the execution trace of E simulated by H exactly
> > >>>> matches a corresponding line that the x86 source-code of E
> > >>>> specifies, why do you lie about this?
> > >>>>
> > >>> No, H does a correct PARTIAL simulation of its input.
> > >>>
> > >>> When you mention that a correct simulation not reaching the end
> > >>> implies non-halting, that means it needs to be a COMPLETE
> > >>> siulation, so your statement is just a LIE.
> > >>>
> > >>> You are being INTENTIONALLY deceptive with shifting definition.
> > >>>
> > >>>
> > >>>> The first seven lines of E are proven to be correctly simulated
> > >>>> by H and also prove that E correctly simulated by every H that
> > >>>> can possibly exist would never reach its own final state and
> > >>>> terminate normally.
> > >>>>
> > >>>>
> > >>>
> > >>> And the "Simulation" of the "CALL" instruction is INCORRECT.
> > >>>
> > >> The seventh line of E simulated by H is the seventh line of the
> > >> x86 source-code of E.
> > >>
> > >> The simulation can only be incorrect when the execution trace of
> > >> the simulated E diverges from what the x86 source-code of E
> > >> specifies, thus you lie again. Why do you insist on lying about
> > >> easily verified facts?
> > >>
> > >>
> > > And it does. How depends on which set of definitons you use.
> > >
> > > We can look at it one of two ways.
> > >
> > > THe first, is that since you are assserting that the failure of
> > > this trace to reach a final state shows that the program is
> > > non-halting, then the fact that in the actual program a "Call H"
> > > instruction continues into the function H, while in the simulation
> > > stops its simulation there.
> >
> > int main() { H(D,D); } D simulated by H never stops running unless
> > aborted and never halts: (reaches its own final state and terminates
> > normally) whether aborted or not. Halt Deciders only report on the
> > behavior of their inputs thus no strawman deception about the
> > behavior of a non-input is any rebuttal at all.
> >
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong
> Olcott: no, you're wrong
> Damon: no, you're wrong

On 11/13/2022 4:33 PM, Dennis Bush wrote:
> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
>> On Sun, 13 Nov 2022 16:08:18 -0600
>> olcott <polc...@gmail.com> wrote:
>>
>>> On 11/13/2022 3:59 PM, Richard Damon wrote:
>>>> On 11/13/22 4:16 PM, olcott wrote:
>>>>> On 11/13/2022 3:02 PM, Richard Damon wrote:
>>>>>> On 11/13/22 3:51 PM, olcott wrote:
>>>>>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>>>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> How does that apply?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> H: Begin Simulation Execution Trace Stored at:15d4d1
>>>>>>>>>>>>> Address_of_H:1383
>>>>>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55 push ebp
>>>>>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
>>>>>>>>>>>>> [00001996][0015d4b9][0014d48d] 51 push ecx
>>>>>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> [0000199a][0015d4b5][00001993] 50 push eax //
>>>>>>>>>>>>> push P [0000199b][0015d4b5][00001993] 8b4d08 mov
>>>>>>>>>>>>> ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51
>>>>>>>>>>>>> push ecx // push P [0000199f][0015d4ad][000019a4]
>>>>>>>>>>>>> e8dff9ffff call 00001383 // call H H: Infinitely Recursive
>>>>>>>>>>>>> Simulation Detected Simulation Stopped
>>>>>>>>>>>>>
>>>>>>>>>>>>> You and I both can see that D correctly simulated by every
>>>>>>>>>>>>> H of the set of H/E pairs will never reach its final state
>>>>>>>>>>>>> and terminate normally.
>>>>>>>>>>>>> Why lie about this?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, we know you are stupid and a liar because the call H
>>>>>>>>>>>> must eventually result in a return of 0 since this run just
>>>>>>>>>>>> shopwed that H(P,P) returns 0.
>>>>>>>>>>>>
>>>>>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>>>>>
>>>>>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>>>>>> simulation never stops running, thus from this we can
>>>>>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
>>>>>>>>>>> correctly simulated by any H ever reaches its own final
>>>>>>>>>>> state and terminates normally.
>>>>>>>>>>>
>>>>>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, but this H DOES abort its simulation, so that doesn't
>>>>>>>>>> matter.
>>>>>>>>> In other words you are saying that infinite loops specify a
>>>>>>>>> sequence of configurations that terminate normally after a
>>>>>>>>> finite number of steps of correct simulation.
>>>>>>>>
>>>>>>>> Nope, but the fact that you think that is what I said shows
>>>>>>>> that you don't understand the material.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> No one denied that, so this is just more of your Red Herring.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> But that isn't the question, since the H you claim is correct
>>>>>>>> doesn't correctly simulate the input since it aborts it.
>>>>>>>>
>>>>>>>> The H that this E is built on DOESN'T correctly simulate its
>>>>>>>> input
>>>>>>>
>>>>>>> _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]
>>>>>>>
>>>>>>> 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
>>>>>>>
>>>>>>> Since I already proved that H does correctly simulate E in that
>>>>>>> every line of the execution trace of E simulated by H exactly
>>>>>>> matches a corresponding line that the x86 source-code of E
>>>>>>> specifies, why do you lie about this?
>>>>>>>
>>>>>> No, H does a correct PARTIAL simulation of its input.
>>>>>>
>>>>>> When you mention that a correct simulation not reaching the end
>>>>>> implies non-halting, that means it needs to be a COMPLETE
>>>>>> siulation, so your statement is just a LIE.
>>>>>>
>>>>>> You are being INTENTIONALLY deceptive with shifting definition.
>>>>>>
>>>>>>
>>>>>>> The first seven lines of E are proven to be correctly simulated
>>>>>>> by H and also prove that E correctly simulated by every H that
>>>>>>> can possibly exist would never reach its own final state and
>>>>>>> terminate normally.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>>>>>
>>>>> The seventh line of E simulated by H is the seventh line of the
>>>>> x86 source-code of E.
>>>>>
>>>>> The simulation can only be incorrect when the execution trace of
>>>>> the simulated E diverges from what the x86 source-code of E
>>>>> specifies, thus you lie again. Why do you insist on lying about
>>>>> easily verified facts?
>>>>>
>>>>>
>>>> And it does. How depends on which set of definitons you use.
>>>>
>>>> We can look at it one of two ways.
>>>>
>>>> THe first, is that since you are assserting that the failure of
>>>> this trace to reach a final state shows that the program is
>>>> non-halting, then the fact that in the actual program a "Call H"
>>>> instruction continues into the function H, while in the simulation
>>>> stops its simulation there.
>>>
>>> int main() { H(D,D); } D simulated by H never stops running unless
>>> aborted and never halts: (reaches its own final state and terminates
>>> normally) whether aborted or not. Halt Deciders only report on the
>>> behavior of their inputs thus no strawman deception about the
>>> behavior of a non-input is any rebuttal at all.
>>>
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>> Olcott: no, you're wrong
>> Damon: no, you're wrong
>
> Actually, it's more like:
>
> Damon: X is wrong because Y
> Olcott: but X is right! Also A.
> Damon: X is still wrong because Y, and A is wrong because B.
> Olcott: (stomps feet) but A is right!! Also F.
> Damon: X is still wrong because Y, and A is still wrong because B, and F is wrong because G.
> Olcott: (throws self on floor, kicking and pounding): but I'm RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>
>

On 11/13/22 5:08 PM, olcott wrote:
> On 11/13/2022 3:59 PM, Richard Damon wrote:
>> On 11/13/22 4:16 PM, olcott wrote:
>>> On 11/13/2022 3:02 PM, Richard Damon wrote:
>>>> On 11/13/22 3:51 PM, olcott wrote:
>>>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> How does that apply?
>>>>>>>>>>>>
>>>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>>>
>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>>>>>>> Address_of_H:1383
>>>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      //
>>>>>>>>>>> push P
>>>>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      //
>>>>>>>>>>> push P
>>>>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 //
>>>>>>>>>>> call H
>>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>
>>>>>>>>>>> You and I both can see that D correctly simulated by every H
>>>>>>>>>>> of the set of H/E pairs will never reach its final state and
>>>>>>>>>>> terminate normally.
>>>>>>>>>>> Why lie about this?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, we know you are stupid and a liar because the call H
>>>>>>>>>> must eventually result in a return of 0 since this run just
>>>>>>>>>> shopwed that H(P,P) returns 0.
>>>>>>>>>>
>>>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>>>
>>>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>>>> simulation never stops running, thus from this we can correctly
>>>>>>>>> infer that no P that has has had 1 to to ∞ steps correctly
>>>>>>>>> simulated by any H ever reaches its own final state and
>>>>>>>>> terminates normally.
>>>>>>>>>
>>>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, but this H DOES abort its simulation, so that doesn't
>>>>>>>> matter.
>>>>>>>>
>>>>>>> In other words you are saying that infinite loops specify a
>>>>>>> sequence of configurations that terminate normally after a finite
>>>>>>> number of steps of correct simulation.
>>>>>>
>>>>>> Nope, but the fact that you think that is what I said shows that
>>>>>> you don't understand the material.
>>>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>
>>>>>> No one denied that, so this is just more of your Red Herring.
>>>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>
>>>>>> But that isn't the question, since the H you claim is correct
>>>>>> doesn't correctly simulate the input since it aborts it.
>>>>>>
>>>>>> The H that this E is built on DOESN'T correctly simulate its input
>>>>>
>>>>> _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]
>>>>>
>>>>> 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
>>>>>
>>>>> Since I already proved that H does correctly simulate E in that
>>>>> every line of the execution trace of E simulated by H exactly
>>>>> matches a corresponding line that the x86 source-code of E
>>>>> specifies, why do you lie about this?
>>>>>
>>>> No, H does a correct PARTIAL simulation of its input.
>>>>
>>>> When you mention that a correct simulation not reaching the end
>>>> implies non-halting, that means it needs to be a COMPLETE siulation,
>>>> so your statement is just a LIE.
>>>>
>>>> You are being INTENTIONALLY deceptive with shifting definition.
>>>>
>>>>
>>>>> The first seven lines of E are proven to be correctly simulated by
>>>>> H and also prove that E correctly simulated by every H that can
>>>>> possibly exist would never reach its own final state and terminate
>>>>> normally.
>>>>>
>>>>>
>>>>
>>>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>>>
>>> The seventh line of E simulated by H is the seventh line of the x86
>>> source-code of E.
>>>
>>> The simulation can only be incorrect when the execution trace of the
>>> simulated E diverges from what the x86 source-code of E specifies,
>>> thus you lie again. Why do you insist on lying about easily verified
>>> facts?
>>>
>>>
>> And it does. How depends on which set of definitons you use.
>>
>> We can look at it one of two ways.
>>
>> THe first, is that since you are assserting that the failure of this
>> trace to reach a final state shows that the program is non-halting,
>> then the fact that in the actual program a "Call H" instruction
>> continues into the function H, while in the simulation stops its
>> simulation there.
>>
>
> int main() { H(D,D); } D simulated by H never stops running unless
> aborted and never halts: (reaches its own final state and terminates
> normally) whether aborted or not. Halt Deciders only report on the
> behavior of their inputs thus no strawman deception about the behavior
> of a non-input is any rebuttal at all.
>

On 11/13/22 5:25 PM, Mr Flibble wrote:
> Olcott: no, you're wrong
> Damon: no, you're wrong
> ...
>
> /Flibble
>

No, Olcott just says that.

I say you are wrong because .... and explain the error.

THere is a difference.

I reference the actual rules and principles.

Olcott just makes up his rules.

You apparently can't tell the difference.

On 11/13/22 5:42 PM, olcott wrote:
> On 11/13/2022 4:33 PM, Dennis Bush wrote:
>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
>>> On Sun, 13 Nov 2022 16:08:18 -0600
>>> Damon: no, you're wrong
>>> Olcott: no, you're wrong
>>> Damon: no, you're wrong
>>
>> Actually, it's more like:
>>
>> Damon: X is wrong because Y
>> Olcott: but X is right!  Also A.
>> Damon: X is still wrong because Y, and A is wrong because B.
>> Olcott: (stomps feet) but A is right!!  Also F.
>> Damon: X is still wrong because Y, and A is still wrong because B, and
>> F is wrong because G.
>> Olcott: (throws self on floor, kicking and pounding):  but I'm
>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>>
>>
>
> In the mean time since your last visit:
>
> MIT Professor Michael Sipser (author of the best selling book on the
> theory of computation) has agreed that the following verbatim paragraph
> is correct (he has not agreed to anything else):
>
>    If simulating halt decider H correctly simulates its input
>    D until H correctly determines that its simulated D would
>    never stop running unless aborted then H can abort its
>    simulation of D and correctly report that D specifies a
>    non-halting sequence of configurations.
>

And his definition of that is that you need to show that a correct AND
COMPLETE simulation of THIS input would never halt.

Thus, you don't get to change the H that D calls, and need to correctly
and completely simualate the D and the H it calls to show the result.

You don't do that.

On 11/13/2022 5:04 PM, Richard Damon wrote:
> On 11/13/22 5:08 PM, olcott wrote:
>> On 11/13/2022 3:59 PM, Richard Damon wrote:
>>> On 11/13/22 4:16 PM, olcott wrote:
>>>> On 11/13/2022 3:02 PM, Richard Damon wrote:
>>>>> On 11/13/22 3:51 PM, olcott wrote:
>>>>>> On 11/13/2022 2:38 PM, Richard Damon wrote:
>>>>>>> On 11/13/22 2:49 PM, olcott wrote:
>>>>>>>> On 11/13/2022 1:34 PM, Richard Damon wrote:
>>>>>>>>> On 11/13/22 10:39 AM, olcott wrote:
>>>>>>>>>> On 11/13/2022 7:00 AM, Richard Damon wrote:
>>>>>>>>>>> On 11/13/22 12:04 AM, olcott wrote:
>>>>>>>>>>>> On 11/12/2022 10:38 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/12/22 11:00 PM, olcott wrote:
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> How does that apply?
>>>>>>>>>>>>>
>>>>>>>>>>>>> H needs a SPECIFIC sequence of instructions.
>>>>>>>>>>>>>
>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:15d4d1
>>>>>>>>>>>> Address_of_H:1383
>>>>>>>>>>>> [00001993][0015d4bd][0015d4c1] 55         push ebp
>>>>>>>>>>>> [00001994][0015d4bd][0015d4c1] 8bec       mov ebp,esp
>>>>>>>>>>>> [00001996][0015d4b9][0014d48d] 51         push ecx
>>>>>>>>>>>> [00001997][0015d4b9][0014d48d] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>> [0000199a][0015d4b5][00001993] 50         push eax      //
>>>>>>>>>>>> push P
>>>>>>>>>>>> [0000199b][0015d4b5][00001993] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>> [0000199e][0015d4b1][00001993] 51         push ecx      //
>>>>>>>>>>>> push P
>>>>>>>>>>>> [0000199f][0015d4ad][000019a4] e8dff9ffff call 00001383 //
>>>>>>>>>>>> call H
>>>>>>>>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> You and I both can see that D correctly simulated by every H
>>>>>>>>>>>> of the set of H/E pairs will never reach its final state and
>>>>>>>>>>>> terminate normally.
>>>>>>>>>>>> Why lie about this?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, we know you are stupid and a liar because the call H
>>>>>>>>>>> must eventually result in a return of 0 since this run just
>>>>>>>>>>> shopwed that H(P,P) returns 0.
>>>>>>>>>>>
>>>>>>>>>>> You have been told this many times and you ignore it.
>>>>>>>>>>
>>>>>>>>>> You told me that P simulated by H that never aborts its
>>>>>>>>>> simulation never stops running, thus from this we can
>>>>>>>>>> correctly infer that no P that has has had 1 to to ∞ steps
>>>>>>>>>> correctly simulated by any H ever reaches its own final state
>>>>>>>>>> and terminates normally.
>>>>>>>>>>
>>>>>>>>>> Why do you use the strawman deception to lie?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, but this H DOES abort its simulation, so that doesn't
>>>>>>>>> matter.
>>>>>>>>>
>>>>>>>> In other words you are saying that infinite loops specify a
>>>>>>>> sequence of configurations that terminate normally after a
>>>>>>>> finite number of steps of correct simulation.
>>>>>>>
>>>>>>> Nope, but the fact that you think that is what I said shows that
>>>>>>> you don't understand the material.
>>>>>>>
>>>>>>>>
>>>>>>>> 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.
>>>>>>>
>>>>>>> No one denied that, so this is just more of your Red Herring.
>>>>>>>
>>>>>>>>
>>>>>>>> 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.
>>>>>>>
>>>>>>> But that isn't the question, since the H you claim is correct
>>>>>>> doesn't correctly simulate the input since it aborts it.
>>>>>>>
>>>>>>> The H that this E is built on DOESN'T correctly simulate its input
>>>>>>
>>>>>> _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]
>>>>>>
>>>>>> 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
>>>>>>
>>>>>> Since I already proved that H does correctly simulate E in that
>>>>>> every line of the execution trace of E simulated by H exactly
>>>>>> matches a corresponding line that the x86 source-code of E
>>>>>> specifies, why do you lie about this?
>>>>>>
>>>>> No, H does a correct PARTIAL simulation of its input.
>>>>>
>>>>> When you mention that a correct simulation not reaching the end
>>>>> implies non-halting, that means it needs to be a COMPLETE
>>>>> siulation, so your statement is just a LIE.
>>>>>
>>>>> You are being INTENTIONALLY deceptive with shifting definition.
>>>>>
>>>>>
>>>>>> The first seven lines of E are proven to be correctly simulated by
>>>>>> H and also prove that E correctly simulated by every H that can
>>>>>> possibly exist would never reach its own final state and terminate
>>>>>> normally.
>>>>>>
>>>>>>
>>>>>
>>>>> And the "Simulation" of the "CALL" instruction is INCORRECT.
>>>>>
>>>> The seventh line of E simulated by H is the seventh line of the x86
>>>> source-code of E.
>>>>
>>>> The simulation can only be incorrect when the execution trace of the
>>>> simulated E diverges from what the x86 source-code of E specifies,
>>>> thus you lie again. Why do you insist on lying about easily verified
>>>> facts?
>>>>
>>>>
>>> And it does. How depends on which set of definitons you use.
>>>
>>> We can look at it one of two ways.
>>>
>>> THe first, is that since you are assserting that the failure of this
>>> trace to reach a final state shows that the program is non-halting,
>>> then the fact that in the actual program a "Call H" instruction
>>> continues into the function H, while in the simulation stops its
>>> simulation there.
>>>
>>
>> int main() { H(D,D); } D simulated by H never stops running unless
>> aborted and never halts: (reaches its own final state and terminates
>> normally) whether aborted or not. Halt Deciders only report on the
>> behavior of their inputs thus no strawman deception about the behavior
>> of a non-input is any rebuttal at all.
>>
>
> But the fact that H never gets to the end is irrelevent, What matters is
> the behavior described by the input which is the direct execution of
> that input, which is the direct execution of it or the correct (and
> complete) simulation of that input.

On 11/13/2022 5:14 PM, Richard Damon wrote:
> On 11/13/22 5:42 PM, olcott wrote:
>> On 11/13/2022 4:33 PM, Dennis Bush wrote:
>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
>>>> On Sun, 13 Nov 2022 16:08:18 -0600
>>>> Damon: no, you're wrong
>>>> Olcott: no, you're wrong
>>>> Damon: no, you're wrong
>>>
>>> Actually, it's more like:
>>>
>>> Damon: X is wrong because Y
>>> Olcott: but X is right!  Also A.
>>> Damon: X is still wrong because Y, and A is wrong because B.
>>> Olcott: (stomps feet) but A is right!!  Also F.
>>> Damon: X is still wrong because Y, and A is still wrong because B,
>>> and F is wrong because G.
>>> Olcott: (throws self on floor, kicking and pounding):  but I'm
>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>>>
>>>
>>
>> In the mean time since your last visit:
>>
>> MIT Professor Michael Sipser (author of the best selling book on the
>> theory of computation) has agreed that the following verbatim
>> paragraph is correct (he has not agreed to anything else):
>>
>>     If simulating halt decider H correctly simulates its input
>>     D until H correctly determines that its simulated D would
>>     never stop running unless aborted then H can abort its
>>     simulation of D and correctly report that D specifies a
>>     non-halting sequence of configurations.
>>
>
> And his definition of that is that you need to show that a correct AND
> COMPLETE simulation of THIS input would never halt.
>

You have already agreed that a correct and complete simulation of P by H
never stops running. Why do you lie about things that you already agreed
to?

> Thus, you don't get to change the H that D calls, and need to correctly
> and completely simualate the D and the H it calls to show the result.
>
> You don't do that.

You already know that there is no need for the simulation to be correct
and complete. We (and H) can infer the behavior of the correct and
complete simulation of D by H on the basis of the correct partial
simulation of D by H.

Why do you insist on lying about this?

--
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 Sun, 13 Nov 2022 18:07:07 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/13/22 5:25 PM, Mr Flibble wrote:
> > Olcott: no, you're wrong
> > Damon: no, you're wrong
> > ...
> >
> > /Flibble
> >
>
> No, Olcott just says that.
>
> I say you are wrong because .... and explain the error.

But what's the point? You should know by now that whatever you say will
not make any difference.

/Flibble

On 11/13/2022 5:14 PM, Richard Damon wrote:
> On 11/13/22 5:42 PM, olcott wrote:
>> On 11/13/2022 4:33 PM, Dennis Bush wrote:
>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble wrote:
>>>> On Sun, 13 Nov 2022 16:08:18 -0600
>>>> Damon: no, you're wrong
>>>> Olcott: no, you're wrong
>>>> Damon: no, you're wrong
>>>
>>> Actually, it's more like:
>>>
>>> Damon: X is wrong because Y
>>> Olcott: but X is right!  Also A.
>>> Damon: X is still wrong because Y, and A is wrong because B.
>>> Olcott: (stomps feet) but A is right!!  Also F.
>>> Damon: X is still wrong because Y, and A is still wrong because B,
>>> and F is wrong because G.
>>> Olcott: (throws self on floor, kicking and pounding):  but I'm
>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>>>
>>>
>>
>> In the mean time since your last visit:
>>
>> MIT Professor Michael Sipser (author of the best selling book on the
>> theory of computation) has agreed that the following verbatim
>> paragraph is correct (he has not agreed to anything else):
>>
>>     If simulating halt decider H correctly simulates its input
>>     D until H correctly determines that its simulated D would
>>     never stop running unless aborted then H can abort its
>>     simulation of D and correctly report that D specifies a
>>     non-halting sequence of configurations.
>>
>
> And his definition of that is that you need to show that a correct AND
> COMPLETE simulation of THIS input would never halt.
H correctly simulates its input D until H correctly
determines that its simulated D would never stop running
unless aborted

Does not freaking say that H must simulate any infinite sequence.
Why do you lie about this?

--
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 Sun, 13 Nov 2022 17:26:23 -0600
olcott <polcott2@gmail.com> wrote:

> On 11/13/2022 5:14 PM, Richard Damon wrote:
> > On 11/13/22 5:42 PM, olcott wrote:
> >> On 11/13/2022 4:33 PM, Dennis Bush wrote:
> >>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble
> >>> wrote:
> >>>> On Sun, 13 Nov 2022 16:08:18 -0600
> >>>> Damon: no, you're wrong
> >>>> Olcott: no, you're wrong
> >>>> Damon: no, you're wrong
> >>>
> >>> Actually, it's more like:
> >>>
> >>> Damon: X is wrong because Y
> >>> Olcott: but X is right!  Also A.
> >>> Damon: X is still wrong because Y, and A is wrong because B.
> >>> Olcott: (stomps feet) but A is right!!  Also F.
> >>> Damon: X is still wrong because Y, and A is still wrong because
> >>> B, and F is wrong because G.
> >>> Olcott: (throws self on floor, kicking and pounding):  but I'm
> >>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
> >>>
> >>>
> >>
> >> In the mean time since your last visit:
> >>
> >> MIT Professor Michael Sipser (author of the best selling book on
> >> the theory of computation) has agreed that the following verbatim
> >> paragraph is correct (he has not agreed to anything else):
> >>
> >>     If simulating halt decider H correctly simulates its input
> >>     D until H correctly determines that its simulated D would
> >>     never stop running unless aborted then H can abort its
> >>     simulation of D and correctly report that D specifies a
> >>     non-halting sequence of configurations.
> >>
> >
> > And his definition of that is that you need to show that a correct
> > AND COMPLETE simulation of THIS input would never halt.
> >
>
> You have already agreed that a correct and complete simulation of P
> by H never stops running. Why do you lie about things that you
> already agreed to?
>
> > Thus, you don't get to change the H that D calls, and need to
> > correctly and completely simualate the D and the H it calls to show
> > the result.
> >
> > You don't do that.
>
> You already know that there is no need for the simulation to be
> correct and complete. We (and H) can infer the behavior of the
> correct and complete simulation of D by H on the basis of the correct
> partial simulation of D by H.
>
> Why do you insist on lying about this?
I agree: if a partial simulation can infer the correct behaviour of a
full simulation then there is no need to run a full simulation; if this
wasn't the case then it would be impossible for a SHD to reach a
decision of non-halting in finite time.

/Flibble

On 11/13/2022 5:52 PM, Mr Flibble wrote:
> On Sun, 13 Nov 2022 17:26:23 -0600
> olcott <polcott2@gmail.com> wrote:
>
>> On 11/13/2022 5:14 PM, Richard Damon wrote:
>>> On 11/13/22 5:42 PM, olcott wrote:
>>>> On 11/13/2022 4:33 PM, Dennis Bush wrote:
>>>>> On Sunday, November 13, 2022 at 5:25:42 PM UTC-5, Mr Flibble
>>>>> wrote:
>>>>>> On Sun, 13 Nov 2022 16:08:18 -0600
>>>>>> Damon: no, you're wrong
>>>>>> Olcott: no, you're wrong
>>>>>> Damon: no, you're wrong
>>>>>
>>>>> Actually, it's more like:
>>>>>
>>>>> Damon: X is wrong because Y
>>>>> Olcott: but X is right!  Also A.
>>>>> Damon: X is still wrong because Y, and A is wrong because B.
>>>>> Olcott: (stomps feet) but A is right!!  Also F.
>>>>> Damon: X is still wrong because Y, and A is still wrong because
>>>>> B, and F is wrong because G.
>>>>> Olcott: (throws self on floor, kicking and pounding):  but I'm
>>>>> RIIIIIIIIIIIIGGGGGGHHHHTTTTTTTT!!!!!!!!!!!
>>>>>
>>>>>
>>>>
>>>> In the mean time since your last visit:
>>>>
>>>> MIT Professor Michael Sipser (author of the best selling book on
>>>> the theory of computation) has agreed that the following verbatim
>>>> paragraph is correct (he has not agreed to anything else):
>>>>
>>>>     If simulating halt decider H correctly simulates its input
>>>>     D until H correctly determines that its simulated D would
>>>>     never stop running unless aborted then H can abort its
>>>>     simulation of D and correctly report that D specifies a
>>>>     non-halting sequence of configurations.
>>>>
>>>
>>> And his definition of that is that you need to show that a correct
>>> AND COMPLETE simulation of THIS input would never halt.
>>>
>>
>> You have already agreed that a correct and complete simulation of P
>> by H never stops running. Why do you lie about things that you
>> already agreed to?
>>
>>> Thus, you don't get to change the H that D calls, and need to
>>> correctly and completely simualate the D and the H it calls to show
>>> the result.
>>>
>>> You don't do that.
>>
>> You already know that there is no need for the simulation to be
>> correct and complete. We (and H) can infer the behavior of the
>> correct and complete simulation of D by H on the basis of the correct
>> partial simulation of D by H.
>>
>> Why do you insist on lying about this?
>
> I agree: if a partial simulation can infer the correct behaviour of a
> full simulation then there is no need to run a full simulation; if this
> wasn't the case then it would be impossible for a SHD to reach a
> decision of non-halting in finite time.
>
> /Flibble
>

Richard seems to simply be a liar.
His goal (like Ben's) is rebuttal at all costs.

--
Copyright 2022 Pete Olcott