On 2/25/23 11:47 PM, olcott wrote:
> On 2/25/2023 9:32 PM, olcott wrote:
>> On 2/25/2023 9:14 PM, olcott wrote:
>>> On 2/25/2023 8:23 PM, Fritz Feldhase wrote:
>>>> On Sunday, February 26, 2023 at 2:28:32 AM UTC+1, olcott wrote:
>>>>
>>>>> H [...] predicts
>>>>
>>>> whatever it predicts. But it does not correctly "predict" (i.e
>>>> determine) the halt status of D(D).
>>>>
>>>
>>> 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.
>>>
>>> The author of the best selling book on the theory of computation has
>>> agreed with these verbatim words: (Ben verified 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 then
>>>
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>
>> Honest reviewers will understand that the above is a tautology*
>> AKA (a) ⊢ (b)
>>
>> *Honest reviewers will also agree that criteria (a) has been met*
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [00001d23] 83c408     add esp,+08
>>   [00001d26] 8945fc     mov [ebp-04],eax
>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>   [00001d2d] 7402       jz 00001d31
>>   [00001d2f] ebfe       jmp 00001d2f
>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>   [00001d34] 8be5       mov esp,ebp
>>   [00001d36] 5d         pop ebp
>>   [00001d37] c3         ret
>>
>>
>> *Therefore H is necessarily correct to reject its input as non-halting*
>>
>> (a)
>> (a) ⊢ (b)
>> ---------
>> ∴ (b)
>
> Liars will disagree that H correctly predicts that D correctly simulated
> by H would never stop running unless aborted.

No, One type of liar is someone who uses the wrong definiton.

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.

Thus for the Halting Problem, the answer is based on the actual behavior
or the machine, since you claim that H is a Halt Decider, it must then
answer based on the actual behavior of the acutal machine. D(D) calls
the H(D,D) that you are claiming is correctly returning 0 (non-halting)
and a trivia analysis of that program shows that if H(D,D) does that,
then D(D) will halt, and you have accepted that as true.

Since H is claimed to be a Halt Decider, the only CORRECT answer it can
therefore give his Halting, so non-halting must be incorrect.

Thus, since you claim your criteria shows it is "non-halting", that
critera is proved to be NOT the same criteria as in the Halting Problem
of Computability Theory, and thus you H isn't a correct Halt Decider of
Computability Theory, and you claim it is one is just a lie.

>
> The way that we can know that they are liars is that they cannot
> possibly show how D correctly simulated by H would stop running if never
> aborted.

Because that doesn't matter. If fact, your statement is NONSENSE.

THat is like saying someone is a liar because they can not tell you if
the liar paradox is true or false.

Your statement is conditioned on a condition that just never happens.
Since you H DOES abort its simulation, talking about the behavior of
something that uses a H that doesn't abort is just fantasy.

>
> They use the example of
> H aborting its simulation as an example of
> H never aborting its simulation.
>
>

But H MUST do only one of them, so if H is correct in aborting its
simulaition, it will ALWAYS abort that simulation, and thus never
doesn't abort that simulation to establish the fact you need.

You are just proving you are a HYPOCRITE because you understand that a
statement is only true if it has a logical link to the axioms
(truth-makers) of the system, but you then insist that you can establish
such a connection about the Halting of a machine, by having H, a single
program, with a single behavior to an input, do two different things
with a given input.

This is just a lie.

YOU are the one saying that a machine that in the end you define to
abort, coult be a machine that never aborts.

LIAR!

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
>

void Infinite_Recursion(u32 N)
{ Infinite_Recursion(N);
}

void Infinite_Loop()
{ HERE: goto HERE;
}

When you deny "would never stop running" that means you affirm
that these two "would stop running" without aborting their simulation.

H(Infinite_Recursion, 0x777);
H(Infinite_Loop);

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

On 2/26/2023 4:22 AM, Mikko wrote:
> On 2023-02-25 15:22:55 +0000, olcott said:
>
>> When I prove that H(D,D) is correct to return 0 indicating that it has
>> correctly predicted that neither the directly executed D(D) nor D
>> correctly simulated by H would ever stop running unless H aborts its
>> simulation then anything outside of this chain of reasoning is not a
>> rebuttal to this reasoning.
>>
>> Anything outside of that chain of reasoning intended as a rebuttal to
>> that chain of reasoning is the strawman deception.
>
> False, because

(a) If simulating halt decider H correctly simulates its input D until H
correctly predicts that its simulated D would never reach its own
"return" statement in any finite number of simulated steps THEN

(b) H can abort its simulation of D and correctly report that D
correctly simulated H specifies a non-halting sequence of
configurations.

The above words are a tautology in that (a) ⊢ (b)

(a)
(a) ⊢ (b)
---------
∴ (b)

Anything outside of this reasoning that attempts to form its rebuttal to
this reasoning <is> the strawman deception.

>
>> *straw-man*
>> An intentionally misrepresented proposition that is set up because it is
>> easier to defeat than an opponent's real argument.
>> https://www.lexico.com/en/definition/straw_man
>
> Mikko
>

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

On 2/25/2023 10:47 PM, olcott wrote:
> On 2/25/2023 9:32 PM, olcott wrote:
>> On 2/25/2023 9:14 PM, olcott wrote:
>>> On 2/25/2023 8:23 PM, Fritz Feldhase wrote:
>>>> On Sunday, February 26, 2023 at 2:28:32 AM UTC+1, olcott wrote:
>>>>
>>>>> H [...] predicts
>>>>
>>>> whatever it predicts. But it does not correctly "predict" (i.e
>>>> determine) the halt status of D(D).
>>>>
>>>
>>> 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.
>>>
>>> The author of the best selling book on the theory of computation has
>>> agreed with these verbatim words: (Ben verified 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 then
>>>
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>
>> Honest reviewers will understand that the above is a tautology*
>> AKA (a) ⊢ (b)
>>
>> *Honest reviewers will also agree that criteria (a) has been met*
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [00001d23] 83c408     add esp,+08
>>   [00001d26] 8945fc     mov [ebp-04],eax
>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>   [00001d2d] 7402       jz 00001d31
>>   [00001d2f] ebfe       jmp 00001d2f
>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>   [00001d34] 8be5       mov esp,ebp
>>   [00001d36] 5d         pop ebp
>>   [00001d37] c3         ret
>>
>>
>> *Therefore H is necessarily correct to reject its input as non-halting*
>>
>> (a)
>> (a) ⊢ (b)
>> ---------
>> ∴ (b)
>
> Liars will disagree that H correctly predicts that D correctly simulated
> by H would never stop running unless aborted.
>
> The way that we can know that they are liars is that they cannot
> possibly show how D correctly simulated by H would stop running if never
> aborted.
>
> They use the example of
> H aborting its simulation as an example of
> H never aborting its simulation.

Like I said when liars find that a line-of-reasoning is irrefutable they
change the subject.

The fact that no one even tried to show how D correctly simulated by H
WOULD stop running if NEVER aborted.

*Is sufficient proof that they already know that*

They fully accept
D correctly simulated by H WOULD NEVER stop running if NEVER aborted.

THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS

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

On 2/26/2023 9:37 AM, Fritz Feldhase wrote:
> On Sunday, February 26, 2023 at 3:57:16 PM UTC+1, olcott wrote:
>> On 2/26/2023 4:31 AM, Mikko wrote:
>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>
>>>> *Never stops running is an infallibly perfect definition of not halting*
>>>>
>>> Indeed, but "would never stop running" is not.
>>>
>> void Infinite_Recursion(u32 N)
>> {
>> Infinite_Recursion(N);
>> }
>>
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> }
>>
>> When you deny "would never stop running" that means you affirm
>> that these two [functions]
>
> "never stop running", you silly crank.
>

*A halt decider must predict what the behavior of its input would be*

Those exact words "would never stop running" in (a) were affirmed by the
author of the best selling book on the theory of computation:

(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 then

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

> This implies that their simulation "never stops running" too
>

see (b)

>> without aborting [it].
>
> So what?

(a)
(a) ⊢ (b)
---------
∴ (b)

Anything outside of the above reasoning provided as a rebuttal to this
reasoning is an example of the strawman deception.

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

On 2/26/23 10:19 AM, olcott wrote:
> On 2/25/2023 10:47 PM, olcott wrote:
>> On 2/25/2023 9:32 PM, olcott wrote:
>>> On 2/25/2023 9:14 PM, olcott wrote:
>>>> On 2/25/2023 8:23 PM, Fritz Feldhase wrote:
>>>>> On Sunday, February 26, 2023 at 2:28:32 AM UTC+1, olcott wrote:
>>>>>
>>>>>> H [...] predicts
>>>>>
>>>>> whatever it predicts. But it does not correctly "predict" (i.e
>>>>> determine) the halt status of D(D).
>>>>>
>>>>
>>>> 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.
>>>>
>>>> The author of the best selling book on the theory of computation has
>>>> agreed with these verbatim words: (Ben verified 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 then
>>>>
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>
>>> Honest reviewers will understand that the above is a tautology*
>>> AKA (a) ⊢ (b)
>>>
>>> *Honest reviewers will also agree that criteria (a) has been met*
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> _D()
>>>   [00001d12] 55         push ebp
>>>   [00001d13] 8bec       mov ebp,esp
>>>   [00001d15] 51         push ecx
>>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>>   [00001d19] 50         push eax         // push D
>>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>>   [00001d1d] 51         push ecx         // push D
>>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>>   [00001d23] 83c408     add esp,+08
>>>   [00001d26] 8945fc     mov [ebp-04],eax
>>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>>   [00001d2d] 7402       jz 00001d31
>>>   [00001d2f] ebfe       jmp 00001d2f
>>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>>   [00001d34] 8be5       mov esp,ebp
>>>   [00001d36] 5d         pop ebp
>>>   [00001d37] c3         ret
>>>
>>>
>>> *Therefore H is necessarily correct to reject its input as non-halting*
>>>
>>> (a)
>>> (a) ⊢ (b)
>>> ---------
>>> ∴ (b)
>>
>> Liars will disagree that H correctly predicts that D correctly simulated
>> by H would never stop running unless aborted.
>>
>> The way that we can know that they are liars is that they cannot
>> possibly show how D correctly simulated by H would stop running if never
>> aborted.
>>
>> They use the example of
>> H aborting its simulation as an example of
>> H never aborting its simulation.
>
> Like I said when liars find that a line-of-reasoning is irrefutable they
> change the subject.

And idiot don't understand logical reasoning.

I guess you are admitting that YOU are the liar, since YOU have changed
the subject for "Actual Halting" to your "POOP not quite Halting".

>
> The fact that no one even tried to show how D correctly simulated by H
> WOULD stop running if NEVER aborted.

The problem of course, is that since D is never correctly simulated by
H, you can't show ANYTHING about what happens when that happens.

Remeber, your H is a DEFINED machine, not something variable, and H DOES
abort its simulation at a point, so you can't talk about what whould
happen if it did something it didn't do.

>
> *Is sufficient proof that they already know that*
>
> They fully accept
> D correctly simulated by H WOULD NEVER stop running if NEVER aborted.
>
> THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
> THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
> THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
> THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
> THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE POINTS
>
>

Lack of showing how your incorrect statments can actually make sense is
affermation that you are an idiot.

Let me try to say it in simple words.

H is a DEFINED Machine, it has a spcified set of code. You get to
propose whatever you want to try to succeed, but once you do, you are
stuck with it.

This is FUNDAMENTAL to how programs work.

Once You have chosen your H, then D is constructed. If you change H,
then a DIFFERENT D will be constructed, but for the given H there will
be a given D that is defined to use a COPY of the program H as part of
its algorithm. It has a copy, because, by definition, programs are whole
self-contained and include ALL of the algorithm they use.

Your current H doesn't actually seem to allow this, as you have said it
is impossible to make a copy of your H in your system, which seems to
imply that you system isn't actually Turing Complete which breaks your
whole arguement, but we can work with it.

By having D call the copy of H that is deciding it, you have taken on
the restriction that since the copy that D called was FIXED by its
definition, now the copy of H that is deciding it is FIXED and we can no
longer make arguements based on varying it, unless we replace the outer
H with the variation, but keep the copy that D called to the original.

THIS IS A FUNDAMENTAL DEFINITION OF HOW PROGRAMS WORK.

Since, by your broken structure, you have imposed the requirement that H
is fixed, you can only argure about what H does, and NOT about what some
alternate H might do, because your system no longer allows for an
alternate H processing this exact input.

In simple symbolic terms, we have defined an H, and a D that uses that H.

If you want to talk about a different H', depending on how you try to do
it, you either end up with H'(D',D') which since the input is different,
doesn't actually tell us anyting about the input D,D, or we need to look
at H'(D,D) but that means the outer H needs to be REPLACED (not changed)
with a different version so D can continue to call the original H.

Now, if we look at your statement.

> D correctly simulated by H WOULD NEVER stop running if NEVER aborted.

Well, NEVER ABORTED doesn't happen for the simulation of D, only for the
simulation of D' which is a DIFFERENT Machine.

Thus, this statement is just not a factual statement, but is one caught
is something similar to the liar's paradox.

If you define H such that it DOES such a correct simulation of the D
built on it, that the simulation will never stop running even if never
aborted, that H can never abort its simulation, and thus fails to answer.

If you define H such that it DOES abort its simulation, then it doesn't
perform a simulation that meets your requirements. We CAN fix the
statement and ask if a correct simulation (not by H) that doesn't abort
will reach a final state, and the answer in this case is YES.

The CORRECT simulation will see D(D) call H(D,D) [the actual one, that
does abort] and this will simulate its input for awhile, and then abort
it simulation and return 0 to the D(D) being simulated by a CORRECT
simulaton and that will see that D(D) halt.

Thus, it is NEVER true for an H that gives an answer to H(D,D) that it
can say that D correctly simulated by H would never stop running if
Never aborted.

Either H DOES abort, so the condition is not true, or H doesn't answer.

You can build all sort contradictory statments when you assume that
something happens that doesn't

Your claim about various H's just fails to be valid, since H needs to be
a fixed machine. There ARE ways to define that sort of thing, but due to
your other "errors" you have closed those off.

If D actually DID have its own copy of H, then you COULD talk about if
the deciding H could show that even if it just simulated for ever, it
would wouldn't halt, because at that point the arguement doesn't change
the machine on the input. But, because you have ERRONEOUSLY tied the two
machines together, that method isn't available, except by REPLACING the
outer H with a DIFFERENT simulator.

On 2/26/23 9:57 AM, olcott wrote:
> 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
>>
>
> void Infinite_Recursion(u32 N)
> {
>   Infinite_Recursion(N);
> }
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> When you deny "would never stop running" that means you affirm
> that these two "would stop running" without aborting their simulation.
>
> H(Infinite_Recursion, 0x777);
> H(Infinite_Loop);
>

And you continue to confuse the Machines never stop running with a
partial simulation of them stop running.

Infinite_Loop and Infinite_Recursion() will never stop running.

You can abort their simulation, but the actual machines continue to "run".

Because of the nature of these machines, it IS possible to prove that
from a sufficient finite partial simulation of them, that the actual
machine will never stop running, as would a simulation that was never
aborted.

This is DIFFERENT than for D(D), as if the H(D,D) aborts its simulation
of D(D) and returns 0 to its calling D(D), we see that D(D) will halt,
and thus THE correct simulation of D(D) does halt, in part BECAUSE this
particular H does abort its simulation (based on incorrect logic) and
give an incorrect answer (again based on its incorrect logic).

THE correct simulation is THE correct simulation, and it halts, and
there can not be another "Correct Simulation" that doesn't halt. Thus,
The Correct Simulation by H" can't be non-halting either. It just
doesn't exist.

On 2/26/23 10:52 AM, olcott wrote:
> On 2/26/2023 9:37 AM, Fritz Feldhase wrote:
>> On Sunday, February 26, 2023 at 3:57:16 PM UTC+1, olcott wrote:
>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>
>>>>> *Never stops running is an infallibly perfect definition of not
>>>>> halting*
>>>>>
>>>> Indeed, but "would never stop running" is not.
>>>>
>>> void Infinite_Recursion(u32 N)
>>> {
>>> Infinite_Recursion(N);
>>> }
>>>
>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }
>>>
>>> When you deny "would never stop running" that means you affirm
>>> that these two [functions]
>>
>> "never stop running", you silly crank.
>>
>
> *A halt decider must predict what the behavior of its input would be*

No, it predicts what the behavior *IS*

Once you define an machine and an input, its behavior is determined and IS.

>
> Those exact words "would never stop running" in (a) were affirmed by the
> author of the best selling book on the theory of computation:
>
> (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 then
>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>

and since you can't prove (a) since this H never does a correct
simulation that isn't aborted (since this H is defined to give an answer)

>
>> This implies that their simulation "never stops running" too
>>
>
> see (b)
>
>>> without aborting [it].
>>
>> So what?
>
> (a)
> (a) ⊢ (b)
> ---------
> ∴ (b)
>
> Anything outside of the above reasoning provided as a rebuttal to this
> reasoning is an example of the strawman deception.
>

Since (a) has never been proven to be possible for this input, you
haven't proven anything.

FAIL.

On 2/26/2023 9:52 AM, olcott wrote:
> On 2/26/2023 9:37 AM, Fritz Feldhase wrote:
>> On Sunday, February 26, 2023 at 3:57:16 PM UTC+1, olcott wrote:
>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>
>>>>> *Never stops running is an infallibly perfect definition of not
>>>>> halting*
>>>>>
>>>> Indeed, but "would never stop running" is not.
>>>>
>>> void Infinite_Recursion(u32 N)
>>> {
>>> Infinite_Recursion(N);
>>> }
>>>
>>> void Infinite_Loop()
>>> {
>>> HERE: goto HERE;
>>> }
>>>
>>> When you deny "would never stop running" that means you affirm
>>> that these two [functions]
>>
>> "never stop running", you silly crank.
>>
>
> *A halt decider must predict what the behavior of its input would be*
>

This is the same as a weather forecaster predicting what the weather
would be. Weather "forecasts" are not very useful if the "forecaster"
only looks out the window to see the current weather.

Likewise a halt decider that only determines that a program never halts
after running it forever.

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

On 2/26/23 10:11 AM, olcott wrote:
> On 2/26/2023 4:22 AM, Mikko wrote:
>> On 2023-02-25 15:22:55 +0000, olcott said:
>>
>>> When I prove that H(D,D) is correct to return 0 indicating that it has
>>> correctly predicted that neither the directly executed D(D) nor D
>>> correctly simulated by H would ever stop running unless H aborts its
>>> simulation then anything outside of this chain of reasoning is not a
>>> rebuttal to this reasoning.
>>>
>>> Anything outside of that chain of reasoning intended as a rebuttal to
>>> that chain of reasoning is the strawman deception.
>>
>> False, because
>
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly predicts that its simulated D would never reach its own
> "return" statement in any finite number of simulated steps THEN
>
> (b) H can abort its simulation of D and correctly report that D
> correctly simulated H specifies a non-halting sequence of
> configurations.
>
> The above words are a tautology in that (a) ⊢ (b)
>
> (a)
> (a) ⊢ (b)
> ---------
> ∴ (b)
>
> Anything outside of this reasoning that attempts to form its rebuttal to
> this reasoning <is> the strawman deception.
>

And you can't establish (a) if you are able to do the action described
in (b).

if H actually does never abort, then you can establish (a), but such a
machine has been restricted from doing (b) by the conditions to get into
this group.

If H does abort, then it can't show (a), as that requires H to not
abort, and that is impossible.

You can't make a machine that both doesn't abort its simulation to prove
(a) and does abort its simulation to do (b).

You are stuck in your own liar's paradox.

>
>>
>>> *straw-man*
>>> An intentionally misrepresented proposition that is set up because it is
>>> easier to defeat than an opponent's real argument.
>>> https://www.lexico.com/en/definition/straw_man
>>
>> Mikko
>>
>

On 2/26/23 1:46 PM, olcott wrote:
> On 2/26/2023 9:52 AM, olcott wrote:
>> On 2/26/2023 9:37 AM, Fritz Feldhase wrote:
>>> On Sunday, February 26, 2023 at 3:57:16 PM UTC+1, olcott wrote:
>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>
>>>>>> *Never stops running is an infallibly perfect definition of not
>>>>>> halting*
>>>>>>
>>>>> Indeed, but "would never stop running" is not.
>>>>>
>>>> void Infinite_Recursion(u32 N)
>>>> {
>>>> Infinite_Recursion(N);
>>>> }
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> When you deny "would never stop running" that means you affirm
>>>> that these two [functions]
>>>
>>> "never stop running", you silly crank.
>>>
>>
>> *A halt decider must predict what the behavior of its input would be*
>>
>
> This is the same as a weather forecaster predicting what the weather
> would be. Weather "forecasts" are not very useful if the "forecaster"
> only looks out the window to see the current weather.
>
> Likewise a halt decider that only determines that a program never halts
> after running it forever.
>

So you don't understand the difference.

A Halt Decider provides in a finite number of steps what might take an
infinite number of steps.

"Time" and thus "Tense" isn't a part of it.

A Computation HAS its behavior as soon as it is designed and an input
decider to apply to it.

The results, while determined, are not known until we perform that
operations. US performing the operations take time. The results were
predetermined by the design as soon as it was designed.

Since we can not know something that can only be know after an infinite
number of steps, A Halt Decider that converts the knowledge of
non-halting behavior from needing an infinite number of steps to the
finite number of steps that decider takes, has moved the answer into
potential knowledge.

Thus a Halt Decider is a Knowledge Generator, it converts the
potentially unknowable "Non-Halting" result into something that is
actually Knowable.

We know that many non-hatling processes can be shown to be non-halting
with just a bit of logic. The question becomes can we determine for ALL
such processes if they will be non-halting as a finite operation. The
ability to do that would greatly expand the sphere of what is knowable.
"Unfortunately" it turns out that it is impossible to determine if ever
arbitrary process will halt or not (but we can determine it for many)
thus some truths will be always out of reach and unknowable.

On Sun, 26 Feb 2023 13:35:55 -0500, Richard Damon wrote:

> On 2/26/23 10:52 AM, olcott wrote:
>> On 2/26/2023 9:37 AM, Fritz Feldhase wrote:
>>> On Sunday, February 26, 2023 at 3:57:16 PM UTC+1, olcott wrote:
>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>
>>>>>> *Never stops running is an infallibly perfect definition of not
>>>>>> halting*
>>>>>>
>>>>> Indeed, but "would never stop running" is not.
>>>>>
>>>> void Infinite_Recursion(u32 N)
>>>> {
>>>> Infinite_Recursion(N);
>>>> }
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> When you deny "would never stop running" that means you affirm that
>>>> these two [functions]
>>>
>>> "never stop running", you silly crank.
>>>
>>>
>> *A halt decider must predict what the behavior of its input would be*
>
> No, it predicts what the behavior *IS*
>
> Once you define an machine and an input, its behavior is determined and
> IS.
>
>
>> Those exact words "would never stop running" in (a) were affirmed by
>> the author of the best selling book on the theory of computation:
>>
>> (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 then
>>
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>>
> and since you can't prove (a) since this H never does a correct
> simulation that isn't aborted (since this H is defined to give an
> answer)
>
>
>>> This implies that their simulation "never stops running" too
>>>
>>>
>> see (b)
>>
>>>> without aborting [it].
>>>
>>> So what?
>>
>> (a)
>> (a) ⊢ (b)
>> ---------
>> ∴ (b)
>>
>> Anything outside of the above reasoning provided as a rebuttal to this
>> reasoning is an example of the strawman deception.
>>
>>
> Since (a) has never been proven to be possible for this input, you
> haven't proven anything.
>
> FAIL.

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

On Sun, 26 Feb 2023 13:24:57 -0500, Richard Damon wrote:

> On 2/26/23 10:19 AM, olcott wrote:
>> On 2/25/2023 10:47 PM, olcott wrote:
>>> On 2/25/2023 9:32 PM, olcott wrote:
>>>> On 2/25/2023 9:14 PM, olcott wrote:
>>>>> On 2/25/2023 8:23 PM, Fritz Feldhase wrote:
>>>>>> On Sunday, February 26, 2023 at 2:28:32 AM UTC+1, olcott wrote:
>>>>>>
>>>>>>> H [...] predicts
>>>>>>
>>>>>> whatever it predicts. But it does not correctly "predict" (i.e
>>>>>> determine) the halt status of D(D).
>>>>>>
>>>>>>
>>>>> 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.
>>>>>
>>>>> The author of the best selling book on the theory of computation has
>>>>> agreed with these verbatim words: (Ben verified 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 then
>>>>>
>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>>
>>>> Honest reviewers will understand that the above is a tautology*
>>>> AKA (a) ⊢ (b)
>>>>
>>>> *Honest reviewers will also agree that criteria (a) has been met*
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> _D()
>>>>   [00001d12] 55         push ebp [00001d13] 8bec       mov ebp,esp
>>>>   [00001d15] 51         push ecx [00001d16] 8b4508     mov
>>>>   eax,[ebp+08] // move 1st argument to eax [00001d19] 50        
>>>>   push eax         // push D [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>>>   // move 1st argument to ecx [00001d1d] 51         push
>>>>   ecx         // push D [00001d1e] e83ff8ffff call 00001562    //
>>>>   call H same as H(D,D) [00001d23] 83c408     add esp,+08
>>>>   [00001d26] 8945fc     mov [ebp-04],eax [00001d29] 837dfc00   cmp
>>>>   dword [ebp-04],+00 [00001d2d] 7402       jz 00001d31 [00001d2f]
>>>>   ebfe       jmp 00001d2f [00001d31] 8b45fc     mov eax,[ebp-04]
>>>>   [00001d34] 8be5       mov esp,ebp [00001d36] 5d         pop ebp
>>>>   [00001d37] c3         ret
>>>>
>>>>
>>>> *Therefore H is necessarily correct to reject its input as
>>>> non-halting*
>>>>
>>>> (a)
>>>> (a) ⊢ (b)
>>>> ---------
>>>> ∴ (b)
>>>
>>> Liars will disagree that H correctly predicts that D correctly
>>> simulated by H would never stop running unless aborted.
>>>
>>> The way that we can know that they are liars is that they cannot
>>> possibly show how D correctly simulated by H would stop running if
>>> never aborted.
>>>
>>> They use the example of H aborting its simulation as an example of H
>>> never aborting its simulation.
>>
>> Like I said when liars find that a line-of-reasoning is irrefutable
>> they change the subject.
>
> And idiot don't understand logical reasoning.
>
> I guess you are admitting that YOU are the liar, since YOU have changed
> the subject for "Actual Halting" to your "POOP not quite Halting".
>
>
>> The fact that no one even tried to show how D correctly simulated by H
>> WOULD stop running if NEVER aborted.
>
> The problem of course, is that since D is never correctly simulated by
> H, you can't show ANYTHING about what happens when that happens.
>
> Remeber, your H is a DEFINED machine, not something variable, and H DOES
> abort its simulation at a point, so you can't talk about what whould
> happen if it did something it didn't do.
>
>
>> *Is sufficient proof that they already know that*
>>
>> They fully accept D correctly simulated by H WOULD NEVER stop running
>> if NEVER aborted.
>>
>> THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF THESE
>> POINTS THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION OF
>> THESE POINTS THE LACK OF ANY REBUTTAL OF THE POINTS IS AN AFFIRMATION
>> OF THESE POINTS THE LACK OF ANY REBUTTAL OF THE POINTS IS AN
>> AFFIRMATION OF THESE POINTS THE LACK OF ANY REBUTTAL OF THE POINTS IS
>> AN AFFIRMATION OF THESE POINTS
>>
>>
>>
> Lack of showing how your incorrect statments can actually make sense is
> affermation that you are an idiot.
>
> Let me try to say it in simple words.
>
> H is a DEFINED Machine, it has a spcified set of code. You get to
> propose whatever you want to try to succeed, but once you do, you are
> stuck with it.
>
> This is FUNDAMENTAL to how programs work.
>
> Once You have chosen your H, then D is constructed. If you change H,
> then a DIFFERENT D will be constructed, but for the given H there will
> be a given D that is defined to use a COPY of the program H as part of
> its algorithm. It has a copy, because, by definition, programs are whole
> self-contained and include ALL of the algorithm they use.
>
> Your current H doesn't actually seem to allow this, as you have said it
> is impossible to make a copy of your H in your system, which seems to
> imply that you system isn't actually Turing Complete which breaks your
> whole arguement, but we can work with it.
>
> By having D call the copy of H that is deciding it, you have taken on
> the restriction that since the copy that D called was FIXED by its
> definition, now the copy of H that is deciding it is FIXED and we can no
> longer make arguements based on varying it, unless we replace the outer
> H with the variation, but keep the copy that D called to the original.
>
> THIS IS A FUNDAMENTAL DEFINITION OF HOW PROGRAMS WORK.
>
> Since, by your broken structure, you have imposed the requirement that H
> is fixed, you can only argure about what H does, and NOT about what some
> alternate H might do, because your system no longer allows for an
> alternate H processing this exact input.
>
> In simple symbolic terms, we have defined an H, and a D that uses that
> H.
>
> If you want to talk about a different H', depending on how you try to do
> it, you either end up with H'(D',D') which since the input is different,
> doesn't actually tell us anyting about the input D,D, or we need to look
> at H'(D,D) but that means the outer H needs to be REPLACED (not changed)
> with a different version so D can continue to call the original H.
>
> Now, if we look at your statement.
>
> > D correctly simulated by H WOULD NEVER stop running if NEVER aborted.
>
> Well, NEVER ABORTED doesn't happen for the simulation of D, only for the
> simulation of D' which is a DIFFERENT Machine.
>
> Thus, this statement is just not a factual statement, but is one caught
> is something similar to the liar's paradox.
>
> If you define H such that it DOES such a correct simulation of the D
> built on it, that the simulation will never stop running even if never
> aborted, that H can never abort its simulation, and thus fails to
> answer.
>
> If you define H such that it DOES abort its simulation, then it doesn't
> perform a simulation that meets your requirements. We CAN fix the
> statement and ask if a correct simulation (not by H) that doesn't abort
> will reach a final state, and the answer in this case is YES.
>
> The CORRECT simulation will see D(D) call H(D,D) [the actual one, that
> does abort] and this will simulate its input for awhile, and then abort
> it simulation and return 0 to the D(D) being simulated by a CORRECT
> simulaton and that will see that D(D) halt.
>
> Thus, it is NEVER true for an H that gives an answer to H(D,D) that it
> can say that D correctly simulated by H would never stop running if
> Never aborted.
>
> Either H DOES abort, so the condition is not true, or H doesn't answer.
>
> You can build all sort contradictory statments when you assume that
> something happens that doesn't
>
> Your claim about various H's just fails to be valid, since H needs to be
> a fixed machine. There ARE ways to define that sort of thing, but due to
> your other "errors" you have closed those off.
>
> If D actually DID have its own copy of H, then you COULD talk about if
> the deciding H could show that even if it just simulated for ever, it
> would wouldn't halt, because at that point the arguement doesn't change
> the machine on the input. But, because you have ERRONEOUSLY tied the two
> machines together, that method isn't available, except by REPLACING the
> outer H with a DIFFERENT simulator.
>
> Since you are trying to use a rule that directly refers to the
> simulation by H, you can only talk about the simulation done by THIS
> EXACT H, and not about other "H"s that might exists, because none of
> those machines can be given the required input.
>
> This is becaue you have incorrectly coded your D to not call the H that
> is claimed to be correct, but to call the H that is deciding it. Thus,
> you can't change that or you whole system is made invalid.
>
>
> The fact that you have gone YEARS (or even DECADES) making this same
> mistake just shows how little you understand about the field.
>
> It seems that you got interested in this problem, not because of the
> problem itself, but because of the impact and influence the theorem, and
> the basic idea behind how it works, impacts so much of logic, and in a
> way you don't seem to be able to understand or accept.
>
> You need to face the fact that it has been shown that it is possible to
> construct logic system capable enough to create truths that the system
> is not able to prove.
>
> You concept of Truth being Provable, inherently limits the capability of
> the logic system it is b=put into. And this level of restriction is
> limited enough that most problems we actually want to solve move beyond
> it.
>
> That is just a fundamental property of logic, that Knowledge will not be
> able to reach all truth, because system just get too "complicated" and
> since we are finite beings, there are limits of what we can get to. Some
> forms of logic can extend our knowledge into restricted domains of the
> infinite, but the infinite goes well past what we can get to.

On Sun, 26 Feb 2023 14:45:45 -0500, Richard Damon wrote:

> On 2/26/23 1:46 PM, olcott wrote:
>> On 2/26/2023 9:52 AM, olcott wrote:
>>> On 2/26/2023 9:37 AM, Fritz Feldhase wrote:
>>>> On Sunday, February 26, 2023 at 3:57:16 PM UTC+1, olcott wrote:
>>>>> On 2/26/2023 4:31 AM, Mikko wrote:
>>>>>> On 2023-02-26 03:48:32 +0000, olcott said:
>>>>>>>
>>>>>>> *Never stops running is an infallibly perfect definition of not
>>>>>>> halting*
>>>>>>>
>>>>>> Indeed, but "would never stop running" is not.
>>>>>>
>>>>> void Infinite_Recursion(u32 N)
>>>>> {
>>>>> Infinite_Recursion(N);
>>>>> }
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>> HERE: goto HERE;
>>>>> }
>>>>>
>>>>> When you deny "would never stop running" that means you affirm that
>>>>> these two [functions]
>>>>
>>>> "never stop running", you silly crank.
>>>>
>>>>
>>> *A halt decider must predict what the behavior of its input would be*
>>>
>>>
>> This is the same as a weather forecaster predicting what the weather
>> would be. Weather "forecasts" are not very useful if the "forecaster"
>> only looks out the window to see the current weather.
>>
>> Likewise a halt decider that only determines that a program never halts
>> after running it forever.
>>
>>
> So you don't understand the difference.
>
> A Halt Decider provides in a finite number of steps what might take an
> infinite number of steps.
>
> "Time" and thus "Tense" isn't a part of it.
>
> A Computation HAS its behavior as soon as it is designed and an input
> decider to apply to it.
>
> The results, while determined, are not known until we perform that
> operations. US performing the operations take time. The results were
> predetermined by the design as soon as it was designed.
>
> Since we can not know something that can only be know after an infinite
> number of steps, A Halt Decider that converts the knowledge of
> non-halting behavior from needing an infinite number of steps to the
> finite number of steps that decider takes, has moved the answer into
> potential knowledge.
>
> Thus a Halt Decider is a Knowledge Generator, it converts the
> potentially unknowable "Non-Halting" result into something that is
> actually Knowable.
>
> We know that many non-hatling processes can be shown to be non-halting
> with just a bit of logic. The question becomes can we determine for ALL
> such processes if they will be non-halting as a finite operation. The
> ability to do that would greatly expand the sphere of what is knowable.
> "Unfortunately" it turns out that it is impossible to determine if ever
> arbitrary process will halt or not (but we can determine it for many)
> thus some truths will be always out of reach and unknowable.

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

On 2/26/23 10:11 AM, olcott wrote:
> On 2/26/2023 4:22 AM, Mikko wrote:
>> On 2023-02-25 15:22:55 +0000, olcott said:
>>
>>> When I prove that H(D,D) is correct to return 0 indicating that it has
>>> correctly predicted that neither the directly executed D(D) nor D
>>> correctly simulated by H would ever stop running unless H aborts its
>>> simulation then anything outside of this chain of reasoning is not a
>>> rebuttal to this reasoning.
>>>
>>> Anything outside of that chain of reasoning intended as a rebuttal to
>>> that chain of reasoning is the strawman deception.
>>
>> False, because
>
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly predicts that its simulated D would never reach its own
> "return" statement in any finite number of simulated steps THEN
>
> (b) H can abort its simulation of D and correctly report that D
> correctly simulated H specifies a non-halting sequence of
> configurations.
>
> The above words are a tautology in that (a) ⊢ (b)

but (a) and (b) are contradictory in behavior.

For a machine to prove (a), it needs to NOT abort its simulation.

For a machine to be able to DO (b), it needs to be able to abort its
simulation.

Any machine that meets (a) can not do (b), so while it can prove it
WOULD be correct to do so, it is unable to do so.

Any machine that does (b), can't look at itself for the simulation that
proves (a).

Thus, no decider can correctly use your logic to do (b).

The simple change of "predicts that *its* simulated D" to the proper
"predicts that *the* correct simulation of D" gives you an actually
usable statement, but then you decider can't do that.

>
> (a)
> (a) ⊢ (b)
> ---------
> ∴ (b)
>
> Anything outside of this reasoning that attempts to form its rebuttal to
> this reasoning <is> the strawman deception.
>

>
>>
>>> *straw-man*
>>> An intentionally misrepresented proposition that is set up because it is
>>> easier to defeat than an opponent's real argument.
>>> https://www.lexico.com/en/definition/straw_man
>>
>> Mikko
>>
>

On Sun, 26 Feb 2023 15:32:48 -0500, Richard Damon wrote:

> On 2/26/23 10:11 AM, olcott wrote:
>> On 2/26/2023 4:22 AM, Mikko wrote:
>>> On 2023-02-25 15:22:55 +0000, olcott said:
>>>
>>>> When I prove that H(D,D) is correct to return 0 indicating that it
>>>> has correctly predicted that neither the directly executed D(D) nor D
>>>> correctly simulated by H would ever stop running unless H aborts its
>>>> simulation then anything outside of this chain of reasoning is not a
>>>> rebuttal to this reasoning.
>>>>
>>>> Anything outside of that chain of reasoning intended as a rebuttal to
>>>> that chain of reasoning is the strawman deception.
>>>
>>> False, because
>>
>> (a) If simulating halt decider H correctly simulates its input D until
>> H correctly predicts that its simulated D would never reach its own
>> "return" statement in any finite number of simulated steps THEN
>>
>> (b) H can abort its simulation of D and correctly report that D
>> correctly simulated H specifies a non-halting sequence of
>> configurations.
>>
>> The above words are a tautology in that (a) ⊢ (b)
>
> but (a) and (b) are contradictory in behavior.
>
> For a machine to prove (a), it needs to NOT abort its simulation.
>
> For a machine to be able to DO (b), it needs to be able to abort its
> simulation.
>
> Any machine that meets (a) can not do (b), so while it can prove it
> WOULD be correct to do so, it is unable to do so.
>
> Any machine that does (b), can't look at itself for the simulation that
> proves (a).
>
> Thus, no decider can correctly use your logic to do (b).
>
> The simple change of "predicts that *its* simulated D" to the proper
> "predicts that *the* correct simulation of D" gives you an actually
> usable statement, but then you decider can't do that.
>
>
>> (a)
>> (a) ⊢ (b)
>> ---------
>> ∴ (b)
>>
>> Anything outside of this reasoning that attempts to form its rebuttal
>> to this reasoning <is> the strawman deception.
>>
>>
>
>
>>
>>>> *straw-man*
>>>> An intentionally misrepresented proposition that is set up because it
>>>> is easier to defeat than an opponent's real argument.
>>>> https://www.lexico.com/en/definition/straw_man
>>>
>>> Mikko
>>>
>>>

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

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.

Mikko

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

void Infinite_Loop()
{ HERE: goto HERE;
}

void Infinite_Recursion(u32 N)
{ Infinite_Recursion(N);
}

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

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.

int main()
{ H0(Infinite_Loop)
H(Infinite_Recursion, 0x777)
HH(Sipser_D, Sipser_D)
}

Infinite simulation is not required to correctly predict that
Infinite_Loop, Infinite_Recursion, and Sipser_D would never stop running
unless their simulation has been aborted.

One of my reviewers seems to believe that infinite behavior cannot be
detected without infinite execution / simulation. This is ridiculous.

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

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
>

void Infinite_Recursion(u32 N)
{ Infinite_Recursion(N);
}

void Infinite_Loop()
{ HERE: goto HERE;
}

When you deny "would never stop running" that means you affirm
that these two "would stop running" without aborting their simulation.

H(Infinite_Recursion, 0x777);
H(Infinite_Loop);

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

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.

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

On Saturday, February 25, 2023 at 4:52:20 PM UTC-8, Richard Damon wrote:
> On 2/25/23 7:36 PM, olcott wrote:
>
> > 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.
>
Thus it is not truly a halt decider because the number of non-halting
behavior patterns must be considered infinite until proven at least
finite and then proven that the "several" is really "all"

On Monday, February 27, 2023 at 7:07:31 AM UTC-8, olcott wrote:
> One of my reviewers seems to believe that infinite behavior cannot be
> detected without infinite execution / simulation. This is ridiculous.

If you mean me - yes, that is a poor way to say it but yes I do believe
that simulation must be infinite to detect ALL possible halting behaviors.
I haven't actually proven this or its negation.

On 2/27/2023 1:32 PM, dklei...@gmail.com wrote:
> On Saturday, February 25, 2023 at 4:52:20 PM UTC-8, Richard Damon wrote:
>> On 2/25/23 7:36 PM, olcott wrote:
>>
>>> 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.
>>
> Thus it is not truly a halt decider because the number of non-halting
> behavior patterns must be considered infinite until proven at least
> finite and then proven that the "several" is really "all"

Because I did not have the 10,000 years required to create a universal
halt decider instead I created a decider that correctly predicts that
the standard "do the opposite of whatever the halt decider decides"
counter-example input to the halting theorem is correctly determined to
be non-halting.

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

On 2/27/2023 1:45 PM, dklei...@gmail.com wrote:
> On Monday, February 27, 2023 at 7:07:31 AM UTC-8, olcott wrote:
>> One of my reviewers seems to believe that infinite behavior cannot be
>> detected without infinite execution / simulation. This is ridiculous.
>
> If you mean me - yes, that is a poor way to say it but yes I do believe
> that simulation must be infinite to detect ALL possible halting behaviors.
> I haven't actually proven this or its negation.

void Infinite_Loop()
{ HERE: goto HERE;
}

So no one and nothing can look at that code and correctly determine that
it is non-halting until after having executed it for eternity and found
that it never stops?

You are one of my honest reviewers.

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

On 2/27/23 10:07 AM, olcott wrote:
> 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.
>>
>> Mikko
>>
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> void Infinite_Recursion(u32 N)
> {
>   Infinite_Recursion(N);
> }
>
> int Sipser_D(int (*M)())
> {
>   if ( HH(M, M) )
>     return 0;
>   return 1;
> }
>
> 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.
>
> int main()
> {
>   H0(Infinite_Loop)
>   H(Infinite_Recursion, 0x777)
>   HH(Sipser_D, Sipser_D)
> }
>
> Infinite simulation is not required to correctly predict that
> Infinite_Loop, Infinite_Recursion, and Sipser_D would never stop running
> unless their simulation has been aborted.
>
> One of my reviewers seems to believe that infinite behavior cannot be
> detected without infinite execution / simulation. This is ridiculous.
>

I haven't heard anyone say that NO infinite behavior can be detected,
just that not all.

You seem to have this problem with confusing Some with All, which may be
why you keep using the fallacy of proof by example.

On 2/27/23 2:55 PM, olcott wrote:
> On 2/27/2023 1:32 PM, dklei...@gmail.com wrote:
>> On Saturday, February 25, 2023 at 4:52:20 PM UTC-8, Richard Damon wrote:
>>> On 2/25/23 7:36 PM, olcott wrote:
>>>
>>>> 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.
>>>
>> Thus it is not truly a halt decider because the number of non-halting
>> behavior patterns must be considered infinite until proven at least
>> finite and then proven that the "several" is really "all"
>
> Because I did not have the 10,000 years required to create a universal
> halt decider instead I created a decider that correctly predicts that
> the standard "do the opposite of whatever the halt decider decides"
> counter-example input to the halting theorem is correctly determined to
> be non-halting.
>

So, the fact that you don't have time to get the required job done is an
excuse to not do it but claim it is done?

You like to just claim that something can be done without giving actual
proof.

This just shows that you don't know what you are talking about, and
don't really care about the problem. but just need for a result to be
true, even if it isn't.

Wanting something to be true doesn't make it true, and assuming it is
becomes a good way to just be wrong.