On 2/28/23 3:01 PM, olcott wrote:

> Maybe only I and the author of the best selling textbook on the theory
> of computation are the only ones smart enough to understand this:
>
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted
>
> (b) then H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> (a) proves (b)
>

But what YOU don't understand that HE does, is that your H doesn't
actually MEET your requirements for (a) because it is impossible

Rmember, HIS definition of a "Correct Simulation" is that of a UTM,
i.e., one that doesn't stop until it finishes.

Thus the simulation of D that HE sees is that of a UTM, and if the
simulation of a UTM doesn't reach and end, then, yes, the machine is
non-halting.

He also understands that the input is an independent thing from the
decider, and so talking about "unless aborted", is only talking about a
hypothetical affecting the decider, and NOT the machine it is simulating.

In his view, if the original H that is claimed to be the correct
answering one does abort and return a 0, and D uses a copy of that
machine, in ALL simulations of that input, that simulation of D will use
the H that aborts that simulation at exactly that same point and returns 0.

Thus, your claim is just a lie.

Since your H NEVER satisifies the requriments, since if the final H you
create that answers aborts its simulation and returns 0, ALL simulations
of D will use that H that does that, so it is impossible for H to
correctly determine that its simulated D would never stop running, since
it DOES stop running without its correct simulation being aborted. That
simulation just can't be done by H, so H can never correctly determine
that it has meet the requirements.

You are just further proving your ignorance.

I will note that it appears that you gave him a carefully crafted
deceptive question that didn't explain exactly what you were doing.

The legal requreiment for interpreting statements in such a case is the
person who didn't craft the statement gets the benefit of the doubt in
ALL matters of interpreation, not the writter.

Since he clearly belives that the correct answer for a Halting decider
is based on the behavior of the machine described, he would agree that
since D(D) halts since H(D,D) returns 0 to it, the only correct answer
that H might have been able to return is Halting.

But H is unable to return a correct answer because is stuck with unsound
logic and bad programming so it will always make this mistake for this
input.

YOU FAIL.

On 2/28/2023 2:01 PM, olcott wrote:
> On 2/28/2023 12:28 PM, olcott wrote:
>> On 2/28/2023 11:37 AM, olcott wrote:
>>> On 2/28/2023 10:54 AM, olcott wrote:
>>>> On 2/28/2023 9:54 AM, olcott wrote:
>>>>> On 2/28/2023 2:47 AM, Mikko wrote:
>>>>>> On 2023-02-27 15:12:31 +0000, olcott said:
>>>>>>
>>>>>>> On 2/27/2023 3:43 AM, Mikko wrote:
>>>>>>>> On 2023-02-26 14:57:12 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>>>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 2/25/2023 9:14 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>>> Since it is an easily verified fact that D(D) would never
>>>>>>>>>>>> stop running
>>>>>>>>>>>> unless H aborts its simulation of D this conclusively proves
>>>>>>>>>>>> beyond all
>>>>>>>>>>>> possible doubt that H is correct to reject its input D as
>>>>>>>>>>>> non-halting.
>>>>>>>>>>
>>>>>>>>>>  ...
>>>>>>>>>>
>>>>>>>>>>> *Never stops running is an infallibly perfect definition of
>>>>>>>>>>> not halting*
>>>>>>>>>>
>>>>>>>>>> Indeed, but "would never stop running" is not.
>>>>>>>>>>
>>>>>>>>>> Mikko
>>>>>>
>>>>>>   ...
>>>>>>> When you deny "would never stop running"
>>>>>>
>>>>>> I don't as a counterfactual is not a truth bearer.
>>>>>> Instead, I notice that you don't deny what I said.
>>>>>>
>>>>>>   ...
>>>>>>> When we put the context back in then you are saying that when I say
>>>>>>> Infinite_Loop() "never stops running" you are saying that this is
>>>>>>> counter-factual.
>>>>>>
>>>>>> No, I'm not. Instead I say that a sentence or clause that contains
>>>>>> the
>>>>>> word "would" is counterfactual because that's what "would" means.
>>>>>>
>>>>>> Mikko
>>>>>>
>>>>>
>>>>> I have no idea what you are saying. It is like you are saying that
>>>>> there
>>>>> is something wrong with if-then statements in programming languages
>>>>> making these if-then statements illegitimate.
>>>>>
>>>>> Categorically exhaustive reasoning totally eliminates all gaps in
>>>>> reasoning by examining every possibility as a set of mutually
>>>>> exclusive
>>>>> hypothetical categories.
>>>>>
>>>>> God exists or God does not exist.
>>>>>    God that exists is pure love or God is not pure love.
>>>>>      God that exists and is pure love
>>>>>        wants the best for his creatures (entailment)
>>>>>
>>>>> D correctly simulated by H only has two possible behaviors for H
>>>>> (a) H aborts its simulation at some point and
>>>>> (b) H that never aborts its simulation
>>>>>
>>>>> The fact that every D of category (a) never stops running conclusively
>>>>> proves that H is correct to abort its simulation and reject D as non-
>>>>> halting.
>>>>>
>>>>
>>>> The fact that neither D(D) nor D correctly simulated by H every stops
>>>> running unless H aborts its simulation of D conclusive proves that H is
>>>> necessarily correct to reject its input as non-halting
>>>>
>>>> *It proves this to liars as well, yet liars lie about it*
>>>>
>>>> *The only possible correct rebuttal is to show how*
>>>> (a) D correctly simulated by H or
>>>> (b) Directly executed D(D) that calls H(D,D)
>>>> Stops running when H never aborted its simulation of its input.
>>>>
>>>> Liars know that they will be caught lying if they try this so they try
>>>> other things that might be convincing to gullible fools.
>>>>
>>>> After being repeated hundreds of times liars still refuse to accept
>>>> that
>>>> simulating halt deciders do correctly predict that their input never
>>>> would stop running. They continue to insist that infinite behavior can
>>>> only be detected by infinite simulation.
>>>>
>>>> A simulating halt decider correctly predicts what the behavior of its
>>>> input would be if this simulated input never had its simulation
>>>> aborted.
>>>> It does this by correctly recognizing several non-halting behavior
>>>> patterns in a finite number of steps of correct simulation.
>>>>
>>>> *H correctly detects three simple infinite behavior patterns*
>>>> (a) Infinite loops
>>>> (b) Infinite recursion
>>>> (c) Recursive simulation
>>>>
>>>>
>>>
>>> A simulating halt decider
>>>
>>> correctly predicts what the behavior of its input would be
>>> correctly predicts what the behavior of its input would be
>>> correctly predicts what the behavior of its input would be
>>> correctly predicts what the behavior of its input would be
>>>
>>> if this simulated input never had its simulation aborted.
>>>
>>> This is the correct criteria for a simulating halt decider that must
>>> itself always halt.
>>
>> When H correctly predicts that D simulated by H would never stop running
>> unless H aborts its simulation of D this also correctly predicts that
>> D(D) would never stop running unless H aborts its simulation of D.
>>
>> Because H correctly predicts the behavior of D(D) simulating halt
>> decider H meets the requirements of a conventional halt decider:
>>
>> In computability theory, the halting problem is the problem of
>> determining, from a description of an arbitrary computer program and an
>> input, whether the program will finish running, or continue to run
>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>
>> *Because H correctly predicts that D(D) would continue to run forever*
>>
>> A simulating halt decider is always correct to abort the simulation of
>> its input and reject this input as non-halting for any input that would
>> never otherwise stop running.
>>
>
> Maybe only I and the author of the best selling textbook on the theory
> of computation are the only ones smart enough to understand this:
>
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted
>
> (b) then H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> (a) proves (b)
>

Brain dead morons can't seem to understand

int Sipser_D(int (*M)())
{ if ( H(M, M) )
return 0;
return 1;
}

Begin Local Halt Decider Simulation Execution Trace Stored at:1133d6
[00001eba][001133c2][001133c6] 55 push ebp // begin Sipser_D
[00001ebb][001133c2][001133c6] 8bec mov ebp,esp
[00001ebd][001133c2][001133c6] 8b4508 mov eax,[ebp+08] // move arg
to eax
[00001ec0][001133be][00001eba] 50 push eax // push
_Sipser_D()
[00001ec1][001133be][00001eba] 8b4d08 mov ecx,[ebp+08] // move arg
to ecx
[00001ec4][001133ba][00001eba] 51 push ecx // push
_Sipser_D()
[00001ec5][001133b6][00001eca] e8a0f5ffff call 0000146a // call H
New slave_stack at:14ddf6
[00001eba][0015ddea][0015ddee] 55 push ebp // begin Sipser_D
[00001ebb][0015ddea][0015ddee] 8bec mov ebp,esp
[00001ebd][0015ddea][0015ddee] 8b4508 mov eax,[ebp+08] // move arg
to eax
[00001ec0][0015dde6][00001eba] 50 push eax // push
_Sipser_D()
[00001ec1][0015dde6][00001eba] 8b4d08 mov ecx,[ebp+08] // move arg
to ecx
[00001ec4][0015dde2][00001eba] 51 push ecx // push
_Sipser_D()
[00001ec5][0015ddde][00001eca] e8a0f5ffff call 0000146a // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

On 2/28/23 3:29 PM, olcott wrote:
> On 2/28/2023 2:01 PM, olcott wrote:
>> On 2/28/2023 12:28 PM, olcott wrote:
>>> On 2/28/2023 11:37 AM, olcott wrote:
>>>> On 2/28/2023 10:54 AM, olcott wrote:
>>>>> On 2/28/2023 9:54 AM, olcott wrote:
>>>>>> On 2/28/2023 2:47 AM, Mikko wrote:
>>>>>>> On 2023-02-27 15:12:31 +0000, olcott said:
>>>>>>>
>>>>>>>> On 2/27/2023 3:43 AM, Mikko wrote:
>>>>>>>>> On 2023-02-26 14:57:12 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>>>>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 2/25/2023 9:14 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> Since it is an easily verified fact that D(D) would never
>>>>>>>>>>>>> stop running
>>>>>>>>>>>>> unless H aborts its simulation of D this conclusively
>>>>>>>>>>>>> proves beyond all
>>>>>>>>>>>>> possible doubt that H is correct to reject its input D as
>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>
>>>>>>>>>>>  ...
>>>>>>>>>>>
>>>>>>>>>>>> *Never stops running is an infallibly perfect definition of
>>>>>>>>>>>> not halting*
>>>>>>>>>>>
>>>>>>>>>>> Indeed, but "would never stop running" is not.
>>>>>>>>>>>
>>>>>>>>>>> Mikko
>>>>>>>
>>>>>>>   ...
>>>>>>>> When you deny "would never stop running"
>>>>>>>
>>>>>>> I don't as a counterfactual is not a truth bearer.
>>>>>>> Instead, I notice that you don't deny what I said.
>>>>>>>
>>>>>>>   ...
>>>>>>>> When we put the context back in then you are saying that when I say
>>>>>>>> Infinite_Loop() "never stops running" you are saying that this is
>>>>>>>> counter-factual.
>>>>>>>
>>>>>>> No, I'm not. Instead I say that a sentence or clause that
>>>>>>> contains the
>>>>>>> word "would" is counterfactual because that's what "would" means.
>>>>>>>
>>>>>>> Mikko
>>>>>>>
>>>>>>
>>>>>> I have no idea what you are saying. It is like you are saying that
>>>>>> there
>>>>>> is something wrong with if-then statements in programming languages
>>>>>> making these if-then statements illegitimate.
>>>>>>
>>>>>> Categorically exhaustive reasoning totally eliminates all gaps in
>>>>>> reasoning by examining every possibility as a set of mutually
>>>>>> exclusive
>>>>>> hypothetical categories.
>>>>>>
>>>>>> God exists or God does not exist.
>>>>>>    God that exists is pure love or God is not pure love.
>>>>>>      God that exists and is pure love
>>>>>>        wants the best for his creatures (entailment)
>>>>>>
>>>>>> D correctly simulated by H only has two possible behaviors for H
>>>>>> (a) H aborts its simulation at some point and
>>>>>> (b) H that never aborts its simulation
>>>>>>
>>>>>> The fact that every D of category (a) never stops running
>>>>>> conclusively
>>>>>> proves that H is correct to abort its simulation and reject D as non-
>>>>>> halting.
>>>>>>
>>>>>
>>>>> The fact that neither D(D) nor D correctly simulated by H every stops
>>>>> running unless H aborts its simulation of D conclusive proves that
>>>>> H is
>>>>> necessarily correct to reject its input as non-halting
>>>>>
>>>>> *It proves this to liars as well, yet liars lie about it*
>>>>>
>>>>> *The only possible correct rebuttal is to show how*
>>>>> (a) D correctly simulated by H or
>>>>> (b) Directly executed D(D) that calls H(D,D)
>>>>> Stops running when H never aborted its simulation of its input.
>>>>>
>>>>> Liars know that they will be caught lying if they try this so they try
>>>>> other things that might be convincing to gullible fools.
>>>>>
>>>>> After being repeated hundreds of times liars still refuse to accept
>>>>> that
>>>>> simulating halt deciders do correctly predict that their input never
>>>>> would stop running. They continue to insist that infinite behavior can
>>>>> only be detected by infinite simulation.
>>>>>
>>>>> A simulating halt decider correctly predicts what the behavior of its
>>>>> input would be if this simulated input never had its simulation
>>>>> aborted.
>>>>> It does this by correctly recognizing several non-halting behavior
>>>>> patterns in a finite number of steps of correct simulation.
>>>>>
>>>>> *H correctly detects three simple infinite behavior patterns*
>>>>> (a) Infinite loops
>>>>> (b) Infinite recursion
>>>>> (c) Recursive simulation
>>>>>
>>>>>
>>>>
>>>> A simulating halt decider
>>>>
>>>> correctly predicts what the behavior of its input would be
>>>> correctly predicts what the behavior of its input would be
>>>> correctly predicts what the behavior of its input would be
>>>> correctly predicts what the behavior of its input would be
>>>>
>>>> if this simulated input never had its simulation aborted.
>>>>
>>>> This is the correct criteria for a simulating halt decider that must
>>>> itself always halt.
>>>
>>> When H correctly predicts that D simulated by H would never stop running
>>> unless H aborts its simulation of D this also correctly predicts that
>>> D(D) would never stop running unless H aborts its simulation of D.
>>>
>>> Because H correctly predicts the behavior of D(D) simulating halt
>>> decider H meets the requirements of a conventional halt decider:
>>>
>>> In computability theory, the halting problem is the problem of
>>> determining, from a description of an arbitrary computer program and an
>>> input, whether the program will finish running, or continue to run
>>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> *Because H correctly predicts that D(D) would continue to run forever*
>>>
>>> A simulating halt decider is always correct to abort the simulation of
>>> its input and reject this input as non-halting for any input that would
>>> never otherwise stop running.
>>>
>>
>> Maybe only I and the author of the best selling textbook on the theory
>> of computation are the only ones smart enough to understand this:
>>
>> (a) If simulating halt decider H correctly simulates its input D until H
>> correctly determines that its simulated D would never stop running
>> unless aborted
>>
>> (b) then H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> (a) proves (b)
>>
>
> Brain dead morons can't seem to understand

Yep, you said it

You just don't understand that since Sipser_D(Sipser_D) will return 1 in
a finite period of time since you are claiming that H will return 0 in a
finite period of time.

Since H is supposed to return the same value is the program it is given
if it returns an answer, it is wrong. PERIOD.

If Sipser_D doesn't return an answer, the ONLY possibility is because H
failed to return an answer to it in finite time, so it is also WRONG.
Note, Sipser_D has no possibility in its own code of not halting, only
in its exact copy of H, which WILL behave just like your "other" H.

Crank Peter Olcott wrote:
....
> Maybe only I and the author of the best selling textbook on the theory

LOL!

On 2/28/2023 2:29 PM, olcott wrote:
> On 2/28/2023 2:01 PM, olcott wrote:
>> On 2/28/2023 12:28 PM, olcott wrote:
>>> On 2/28/2023 11:37 AM, olcott wrote:
>>>> On 2/28/2023 10:54 AM, olcott wrote:
>>>>> On 2/28/2023 9:54 AM, olcott wrote:
>>>>>> On 2/28/2023 2:47 AM, Mikko wrote:
>>>>>>> On 2023-02-27 15:12:31 +0000, olcott said:
>>>>>>>
>>>>>>>> On 2/27/2023 3:43 AM, Mikko wrote:
>>>>>>>>> On 2023-02-26 14:57:12 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>>>>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 2/25/2023 9:14 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> Since it is an easily verified fact that D(D) would never
>>>>>>>>>>>>> stop running
>>>>>>>>>>>>> unless H aborts its simulation of D this conclusively
>>>>>>>>>>>>> proves beyond all
>>>>>>>>>>>>> possible doubt that H is correct to reject its input D as
>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>
>>>>>>>>>>>  ...
>>>>>>>>>>>
>>>>>>>>>>>> *Never stops running is an infallibly perfect definition of
>>>>>>>>>>>> not halting*
>>>>>>>>>>>
>>>>>>>>>>> Indeed, but "would never stop running" is not.
>>>>>>>>>>>
>>>>>>>>>>> Mikko
>>>>>>>
>>>>>>>   ...
>>>>>>>> When you deny "would never stop running"
>>>>>>>
>>>>>>> I don't as a counterfactual is not a truth bearer.
>>>>>>> Instead, I notice that you don't deny what I said.
>>>>>>>
>>>>>>>   ...
>>>>>>>> When we put the context back in then you are saying that when I say
>>>>>>>> Infinite_Loop() "never stops running" you are saying that this is
>>>>>>>> counter-factual.
>>>>>>>
>>>>>>> No, I'm not. Instead I say that a sentence or clause that
>>>>>>> contains the
>>>>>>> word "would" is counterfactual because that's what "would" means.
>>>>>>>
>>>>>>> Mikko
>>>>>>>
>>>>>>
>>>>>> I have no idea what you are saying. It is like you are saying that
>>>>>> there
>>>>>> is something wrong with if-then statements in programming languages
>>>>>> making these if-then statements illegitimate.
>>>>>>
>>>>>> Categorically exhaustive reasoning totally eliminates all gaps in
>>>>>> reasoning by examining every possibility as a set of mutually
>>>>>> exclusive
>>>>>> hypothetical categories.
>>>>>>
>>>>>> God exists or God does not exist.
>>>>>>    God that exists is pure love or God is not pure love.
>>>>>>      God that exists and is pure love
>>>>>>        wants the best for his creatures (entailment)
>>>>>>
>>>>>> D correctly simulated by H only has two possible behaviors for H
>>>>>> (a) H aborts its simulation at some point and
>>>>>> (b) H that never aborts its simulation
>>>>>>
>>>>>> The fact that every D of category (a) never stops running
>>>>>> conclusively
>>>>>> proves that H is correct to abort its simulation and reject D as non-
>>>>>> halting.
>>>>>>
>>>>>
>>>>> The fact that neither D(D) nor D correctly simulated by H every stops
>>>>> running unless H aborts its simulation of D conclusive proves that
>>>>> H is
>>>>> necessarily correct to reject its input as non-halting
>>>>>
>>>>> *It proves this to liars as well, yet liars lie about it*
>>>>>
>>>>> *The only possible correct rebuttal is to show how*
>>>>> (a) D correctly simulated by H or
>>>>> (b) Directly executed D(D) that calls H(D,D)
>>>>> Stops running when H never aborted its simulation of its input.
>>>>>
>>>>> Liars know that they will be caught lying if they try this so they try
>>>>> other things that might be convincing to gullible fools.
>>>>>
>>>>> After being repeated hundreds of times liars still refuse to accept
>>>>> that
>>>>> simulating halt deciders do correctly predict that their input never
>>>>> would stop running. They continue to insist that infinite behavior can
>>>>> only be detected by infinite simulation.
>>>>>
>>>>> A simulating halt decider correctly predicts what the behavior of its
>>>>> input would be if this simulated input never had its simulation
>>>>> aborted.
>>>>> It does this by correctly recognizing several non-halting behavior
>>>>> patterns in a finite number of steps of correct simulation.
>>>>>
>>>>> *H correctly detects three simple infinite behavior patterns*
>>>>> (a) Infinite loops
>>>>> (b) Infinite recursion
>>>>> (c) Recursive simulation
>>>>>
>>>>>
>>>>
>>>> A simulating halt decider
>>>>
>>>> correctly predicts what the behavior of its input would be
>>>> correctly predicts what the behavior of its input would be
>>>> correctly predicts what the behavior of its input would be
>>>> correctly predicts what the behavior of its input would be
>>>>
>>>> if this simulated input never had its simulation aborted.
>>>>
>>>> This is the correct criteria for a simulating halt decider that must
>>>> itself always halt.
>>>
>>> When H correctly predicts that D simulated by H would never stop running
>>> unless H aborts its simulation of D this also correctly predicts that
>>> D(D) would never stop running unless H aborts its simulation of D.
>>>
>>> Because H correctly predicts the behavior of D(D) simulating halt
>>> decider H meets the requirements of a conventional halt decider:
>>>
>>> In computability theory, the halting problem is the problem of
>>> determining, from a description of an arbitrary computer program and an
>>> input, whether the program will finish running, or continue to run
>>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> *Because H correctly predicts that D(D) would continue to run forever*
>>>
>>> A simulating halt decider is always correct to abort the simulation of
>>> its input and reject this input as non-halting for any input that would
>>> never otherwise stop running.
>>>
>>
>> Maybe only I and the author of the best selling textbook on the theory
>> of computation are the only ones smart enough to understand this:
>>
>> (a) If simulating halt decider H correctly simulates its input D until H
>> correctly determines that its simulated D would never stop running
>> unless aborted
>>
>> (b) then H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> (a) proves (b)
>>
>
> Brain dead morons can't seem to understand
>
> int Sipser_D(int (*M)())
> {
>   if ( H(M, M) )
>     return 0;
>   return 1;
> }
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:1133d6
> [00001eba][001133c2][001133c6] 55         push ebp         // begin
> Sipser_D
> [00001ebb][001133c2][001133c6] 8bec       mov ebp,esp
> [00001ebd][001133c2][001133c6] 8b4508     mov eax,[ebp+08] // move arg
> to eax
> [00001ec0][001133be][00001eba] 50         push eax         // push
> _Sipser_D()
> [00001ec1][001133be][00001eba] 8b4d08     mov ecx,[ebp+08] // move arg
> to ecx
> [00001ec4][001133ba][00001eba] 51         push ecx         // push
> _Sipser_D()
> [00001ec5][001133b6][00001eca] e8a0f5ffff call 0000146a    // call H
> New slave_stack at:14ddf6
> [00001eba][0015ddea][0015ddee] 55         push ebp         // begin
> Sipser_D
> [00001ebb][0015ddea][0015ddee] 8bec       mov ebp,esp
> [00001ebd][0015ddea][0015ddee] 8b4508     mov eax,[ebp+08] // move arg
> to eax
> [00001ec0][0015dde6][00001eba] 50         push eax         // push
> _Sipser_D()
> [00001ec1][0015dde6][00001eba] 8b4d08     mov ecx,[ebp+08] // move arg
> to ecx
> [00001ec4][0015dde2][00001eba] 51         push ecx         // push
> _Sipser_D()
> [00001ec5][0015ddde][00001eca] e8a0f5ffff call 0000146a    // call H
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> That the above behavior pattern conclusive proves that
> Sipser_D(Sipser_D) cannot possibly stop running unless H aborts its
> simulation of Sipser_D.

On 2/28/23 4:51 PM, olcott wrote:
> On 2/28/2023 2:29 PM, olcott wrote:
>> On 2/28/2023 2:01 PM, olcott wrote:
>>> On 2/28/2023 12:28 PM, olcott wrote:
>>>> On 2/28/2023 11:37 AM, olcott wrote:
>>>>> On 2/28/2023 10:54 AM, olcott wrote:
>>>>>> On 2/28/2023 9:54 AM, olcott wrote:
>>>>>>> On 2/28/2023 2:47 AM, Mikko wrote:
>>>>>>>> On 2023-02-27 15:12:31 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 2/27/2023 3:43 AM, Mikko wrote:
>>>>>>>>>> On 2023-02-26 14:57:12 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>>>>>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 2/25/2023 9:14 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>> Since it is an easily verified fact that D(D) would never
>>>>>>>>>>>>>> stop running
>>>>>>>>>>>>>> unless H aborts its simulation of D this conclusively
>>>>>>>>>>>>>> proves beyond all
>>>>>>>>>>>>>> possible doubt that H is correct to reject its input D as
>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>>  ...
>>>>>>>>>>>>
>>>>>>>>>>>>> *Never stops running is an infallibly perfect definition of
>>>>>>>>>>>>> not halting*
>>>>>>>>>>>>
>>>>>>>>>>>> Indeed, but "would never stop running" is not.
>>>>>>>>>>>>
>>>>>>>>>>>> Mikko
>>>>>>>>
>>>>>>>>   ...
>>>>>>>>> When you deny "would never stop running"
>>>>>>>>
>>>>>>>> I don't as a counterfactual is not a truth bearer.
>>>>>>>> Instead, I notice that you don't deny what I said.
>>>>>>>>
>>>>>>>>   ...
>>>>>>>>> When we put the context back in then you are saying that when I
>>>>>>>>> say
>>>>>>>>> Infinite_Loop() "never stops running" you are saying that this is
>>>>>>>>> counter-factual.
>>>>>>>>
>>>>>>>> No, I'm not. Instead I say that a sentence or clause that
>>>>>>>> contains the
>>>>>>>> word "would" is counterfactual because that's what "would" means.
>>>>>>>>
>>>>>>>> Mikko
>>>>>>>>
>>>>>>>
>>>>>>> I have no idea what you are saying. It is like you are saying
>>>>>>> that there
>>>>>>> is something wrong with if-then statements in programming languages
>>>>>>> making these if-then statements illegitimate.
>>>>>>>
>>>>>>> Categorically exhaustive reasoning totally eliminates all gaps in
>>>>>>> reasoning by examining every possibility as a set of mutually
>>>>>>> exclusive
>>>>>>> hypothetical categories.
>>>>>>>
>>>>>>> God exists or God does not exist.
>>>>>>>    God that exists is pure love or God is not pure love.
>>>>>>>      God that exists and is pure love
>>>>>>>        wants the best for his creatures (entailment)
>>>>>>>
>>>>>>> D correctly simulated by H only has two possible behaviors for H
>>>>>>> (a) H aborts its simulation at some point and
>>>>>>> (b) H that never aborts its simulation
>>>>>>>
>>>>>>> The fact that every D of category (a) never stops running
>>>>>>> conclusively
>>>>>>> proves that H is correct to abort its simulation and reject D as
>>>>>>> non-
>>>>>>> halting.
>>>>>>>
>>>>>>
>>>>>> The fact that neither D(D) nor D correctly simulated by H every stops
>>>>>> running unless H aborts its simulation of D conclusive proves that
>>>>>> H is
>>>>>> necessarily correct to reject its input as non-halting
>>>>>>
>>>>>> *It proves this to liars as well, yet liars lie about it*
>>>>>>
>>>>>> *The only possible correct rebuttal is to show how*
>>>>>> (a) D correctly simulated by H or
>>>>>> (b) Directly executed D(D) that calls H(D,D)
>>>>>> Stops running when H never aborted its simulation of its input.
>>>>>>
>>>>>> Liars know that they will be caught lying if they try this so they
>>>>>> try
>>>>>> other things that might be convincing to gullible fools.
>>>>>>
>>>>>> After being repeated hundreds of times liars still refuse to
>>>>>> accept that
>>>>>> simulating halt deciders do correctly predict that their input never
>>>>>> would stop running. They continue to insist that infinite behavior
>>>>>> can
>>>>>> only be detected by infinite simulation.
>>>>>>
>>>>>> A simulating halt decider correctly predicts what the behavior of its
>>>>>> input would be if this simulated input never had its simulation
>>>>>> aborted.
>>>>>> It does this by correctly recognizing several non-halting behavior
>>>>>> patterns in a finite number of steps of correct simulation.
>>>>>>
>>>>>> *H correctly detects three simple infinite behavior patterns*
>>>>>> (a) Infinite loops
>>>>>> (b) Infinite recursion
>>>>>> (c) Recursive simulation
>>>>>>
>>>>>>
>>>>>
>>>>> A simulating halt decider
>>>>>
>>>>> correctly predicts what the behavior of its input would be
>>>>> correctly predicts what the behavior of its input would be
>>>>> correctly predicts what the behavior of its input would be
>>>>> correctly predicts what the behavior of its input would be
>>>>>
>>>>> if this simulated input never had its simulation aborted.
>>>>>
>>>>> This is the correct criteria for a simulating halt decider that must
>>>>> itself always halt.
>>>>
>>>> When H correctly predicts that D simulated by H would never stop
>>>> running
>>>> unless H aborts its simulation of D this also correctly predicts that
>>>> D(D) would never stop running unless H aborts its simulation of D.
>>>>
>>>> Because H correctly predicts the behavior of D(D) simulating halt
>>>> decider H meets the requirements of a conventional halt decider:
>>>>
>>>> In computability theory, the halting problem is the problem of
>>>> determining, from a description of an arbitrary computer program and an
>>>> input, whether the program will finish running, or continue to run
>>>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> *Because H correctly predicts that D(D) would continue to run forever*
>>>>
>>>> A simulating halt decider is always correct to abort the simulation of
>>>> its input and reject this input as non-halting for any input that would
>>>> never otherwise stop running.
>>>>
>>>
>>> Maybe only I and the author of the best selling textbook on the theory
>>> of computation are the only ones smart enough to understand this:
>>>
>>> (a) If simulating halt decider H correctly simulates its input D until H
>>> correctly determines that its simulated D would never stop running
>>> unless aborted
>>>
>>> (b) then H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> (a) proves (b)
>>>
>>
>> Brain dead morons can't seem to understand
>>
>> int Sipser_D(int (*M)())
>> {
>>    if ( H(M, M) )
>>      return 0;
>>    return 1;
>> }
>>
>> Begin Local Halt Decider Simulation   Execution Trace Stored at:1133d6
>> [00001eba][001133c2][001133c6] 55         push ebp         // begin
>> Sipser_D
>> [00001ebb][001133c2][001133c6] 8bec       mov ebp,esp
>> [00001ebd][001133c2][001133c6] 8b4508     mov eax,[ebp+08] // move arg
>> to eax
>> [00001ec0][001133be][00001eba] 50         push eax         // push
>> _Sipser_D()
>> [00001ec1][001133be][00001eba] 8b4d08     mov ecx,[ebp+08] // move arg
>> to ecx
>> [00001ec4][001133ba][00001eba] 51         push ecx         // push
>> _Sipser_D()
>> [00001ec5][001133b6][00001eca] e8a0f5ffff call 0000146a    // call H
>> New slave_stack at:14ddf6
>> [00001eba][0015ddea][0015ddee] 55         push ebp         // begin
>> Sipser_D
>> [00001ebb][0015ddea][0015ddee] 8bec       mov ebp,esp
>> [00001ebd][0015ddea][0015ddee] 8b4508     mov eax,[ebp+08] // move arg
>> to eax
>> [00001ec0][0015dde6][00001eba] 50         push eax         // push
>> _Sipser_D()
>> [00001ec1][0015dde6][00001eba] 8b4d08     mov ecx,[ebp+08] // move arg
>> to ecx
>> [00001ec4][0015dde2][00001eba] 51         push ecx         // push
>> _Sipser_D()
>> [00001ec5][0015ddde][00001eca] e8a0f5ffff call 0000146a    // call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> That the above behavior pattern conclusive proves that
>> Sipser_D(Sipser_D) cannot possibly stop running unless H aborts its
>> simulation of Sipser_D.
>
> The above trace comes from this direct execution.

On 2023-02-28 15:54:59 +0000, olcott said:

> On 2/28/2023 2:47 AM, Mikko wrote:

>> No, I'm not. Instead I say that a sentence or clause that contains the
>> word "would" is counterfactual because that's what "would" means.
>>
>> Mikko

> I have no idea what you are saying. It is like you are saying that there
> is something wrong with if-then statements in programming languages
> making these if-then statements illegitimate.

Not all if-statements, only those that contain the keyword "would"
are invalid in C and every programming language that I know.

Mikko

On 3/1/2023 4:03 AM, Mikko wrote:
> On 2023-02-28 15:54:59 +0000, olcott said:
>
>> On 2/28/2023 2:47 AM, Mikko wrote:
>
>>> No, I'm not. Instead I say that a sentence or clause that contains the
>>> word "would" is counterfactual because that's what "would" means.
>>>
>>> Mikko
>
>> I have no idea what you are saying. It is like you are saying that there
>> is something wrong with if-then statements in programming languages
>> making these if-then statements illegitimate.
>
> Not all if-statements, only those that contain the keyword "would"
> are invalid in C and every programming language that I know.
>
> Mikko
>

I give up on you. You ignore too many of my words.

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