When simulating halt decider H correctly predicts that directly executed
D(D) would remain stuck in recursive simulation (run forever) unless H
aborts its simulation of D this directly applies to the halting theorem
because H correctly determines:

from a description of an arbitrary computer program and an input,
whether the program will finish running, or continue to run forever.

For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem

01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that simulates
D(D) at line 03 ...

When it is understood that halting requires reaching a final state and
stopping for any other reason does not count as halting then

The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.

When H returns 0 it is only affirming this verified fact.

When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.

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

On 3/17/23 12:54 PM, olcott wrote:
> When simulating halt decider H correctly predicts that directly executed
> D(D) would remain stuck in recursive simulation (run forever) unless H
> aborts its simulation of D this directly applies to the halting theorem
> because H correctly determines:
>
>    from a description of an arbitrary computer program and an input,
>    whether the program will finish running, or continue to run forever.
>
>    For any program H that might determine whether programs halt,
>    a "pathological" program D, called with some input, can pass its
>    own source and its input to H and then specifically do the opposite
>    of what H predicts D will do.
> https://en.wikipedia.org/wiki/Halting_problem
>
> 01 int D(int (*x)())
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> Here is the sequence when H never aborts it simulation: proving (a)
>   main() calls H(D,D) that simulates D(D) at line 11
>   keeps repeating: simulated D(D) calls simulated H(D,D) that simulates
> D(D) at line 03 ...

Which since H actually DOES abort, is irrelevent.

>
> When it is understood that halting requires reaching a final state and
> stopping for any other reason does not count as halting then

Right, but D(D) does Halt, as you have admitted, it is just that the H
that gives an answer is incapable of reaching that point in its simulation.

>
> The fact that D correctly simulated by H cannot possibly reach its own
> final state at line 6 conclusively proves that this D does not halt.

Except that D is NOT "Correctly simulated" by any meaning that also
identifies input that represents Halting Machine, says that your premis
is just FALSE

>
> When H returns 0 it is only affirming this verified fact.

Nope, it is afferming that its UNSOUND LOGIC lead to that fact.

>
> When it is understood that all deciders compute the mapping from their
> inputs to a final accept or reject state then it is understood that H
> must only evaluate the behavior of its input and the behavior of non-
> inputs is not allowed to be considered.
>

Right, and the INPUT to H is the DESCRIPTION of the Machine D and its
input, and the mapping it is being asked to compute is from the behavior
of that actual machine and input to Halting and non-halting. The fact
that this mapping isn't actually computable, just points out that an H
can not exist to do the task.

Thus, you claims that you "Have" to ask H something else, is just an
admission that the Halt Theorem, which states that this mapping is not
computable, is, in fact correct, not refuted as you claim.

On 3/17/2023 11:54 AM, olcott wrote:
> When simulating halt decider H correctly predicts that directly executed
> D(D) would remain stuck in recursive simulation (run forever) unless H
> aborts its simulation of D this directly applies to the halting theorem
> because H correctly determines:
>
>    from a description of an arbitrary computer program and an input,
>    whether the program will finish running, or continue to run forever.
>
>    For any program H that might determine whether programs halt,
>    a "pathological" program D, called with some input, can pass its
>    own source and its input to H and then specifically do the opposite
>    of what H predicts D will do.
> https://en.wikipedia.org/wiki/Halting_problem
>
> 01 int D(int (*x)())
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> Here is the sequence when H never aborts it simulation: proving (a)
>   main() calls H(D,D) that simulates D(D) at line 11
>   keeps repeating: simulated D(D) calls simulated H(D,D) that simulates
> D(D) at line 03 ...
>
> When it is understood that halting requires reaching a final state and
> stopping for any other reason does not count as halting then
>
> The fact that D correctly simulated by H cannot possibly reach its own
> final state at line 6 conclusively proves that this D does not halt.
>
> When H returns 0 it is only affirming this verified fact.
>
> When it is understood that all deciders compute the mapping from their
> inputs to a final accept or reject state then it is understood that H
> must only evaluate the behavior of its input and the behavior of non-
> inputs is not allowed to be considered.
>

Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible
H cannot possibly reach past its own line 3.

When we combine this verified fact with the fact that halting requires
reaching the final state, and stopping running for any other reason does
not count as halting then D correctly simulated by H cannot possibly
halt no matter what H does.

This conclusively proves that when H returns 0 it is only affirming the
above verified fact.

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

On 3/17/23 3:43 PM, olcott wrote:
> On 3/17/2023 11:54 AM, olcott wrote:
>> When simulating halt decider H correctly predicts that directly
>> executed D(D) would remain stuck in recursive simulation (run forever)
>> unless H aborts its simulation of D this directly applies to the
>> halting theorem because H correctly determines:
>>
>>     from a description of an arbitrary computer program and an input,
>>     whether the program will finish running, or continue to run forever.
>>
>>     For any program H that might determine whether programs halt,
>>     a "pathological" program D, called with some input, can pass its
>>     own source and its input to H and then specifically do the opposite
>>     of what H predicts D will do.
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> 01 int D(int (*x)())
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> Here is the sequence when H never aborts it simulation: proving (a)
>>    main() calls H(D,D) that simulates D(D) at line 11
>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>> simulates D(D) at line 03 ...
>>
>> When it is understood that halting requires reaching a final state and
>> stopping for any other reason does not count as halting then
>>
>> The fact that D correctly simulated by H cannot possibly reach its own
>> final state at line 6 conclusively proves that this D does not halt.
>>
>> When H returns 0 it is only affirming this verified fact.
>>
>> When it is understood that all deciders compute the mapping from their
>> inputs to a final accept or reject state then it is understood that H
>> must only evaluate the behavior of its input and the behavior of non-
>> inputs is not allowed to be considered.
>>
>
> Anyone with sufficient software engineering knowledge knows that D
> correctly simulated by any element of the infinite set of every possible
> H cannot possibly reach past its own line 3.

No, the ACTUAL D which is defined to call the ORIGINAL H, not another
member of the set, will be seen to halt by any other member of the set
if H-like programs that are given that input that simulates this input
long enough.

If you give an H-like program a DIFFERENT D-like input based on it, then
that answer means nothing about the original input D, since it isn't it.

You are just showing your total lack of understand of anything relating
to the problem.

>
> When we combine this verified fact with the fact that halting requires
> reaching the final state, and stopping running for any other reason does
> not count as halting then D correctly simulated by H cannot possibly
> halt no matter what H does.

You mean when we combine your verified LIE, we see that you claim is bogus.

Remember, H and D refer to SPECIFIC PROGRAMS, not "Sets". Try to do this
in your actual program, define TWO different deciders called "H" and see
what happens.

It seems you flunked programing 101.

>
> This conclusively proves that when H returns 0 it is only affirming the
> above verified fact.
>

Nope, it conclusively proves that Peter Olcott doesn't know what he is
talking about.

On 3/17/2023 2:43 PM, olcott wrote:
> On 3/17/2023 11:54 AM, olcott wrote:
>> When simulating halt decider H correctly predicts that directly
>> executed D(D) would remain stuck in recursive simulation (run forever)
>> unless H aborts its simulation of D this directly applies to the
>> halting theorem because H correctly determines:
>>
>>     from a description of an arbitrary computer program and an input,
>>     whether the program will finish running, or continue to run forever.
>>
>>     For any program H that might determine whether programs halt,
>>     a "pathological" program D, called with some input, can pass its
>>     own source and its input to H and then specifically do the opposite
>>     of what H predicts D will do.
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> 01 int D(int (*x)())
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> Here is the sequence when H never aborts it simulation: proving (a)
>>    main() calls H(D,D) that simulates D(D) at line 11
>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>> simulates D(D) at line 03 ...
>>
>> When it is understood that halting requires reaching a final state and
>> stopping for any other reason does not count as halting then
>>
>> The fact that D correctly simulated by H cannot possibly reach its own
>> final state at line 6 conclusively proves that this D does not halt.
>>
>> When H returns 0 it is only affirming this verified fact.
>>
>> When it is understood that all deciders compute the mapping from their
>> inputs to a final accept or reject state then it is understood that H
>> must only evaluate the behavior of its input and the behavior of non-
>> inputs is not allowed to be considered.
>>
>
> Anyone with sufficient software engineering knowledge knows that D
> correctly simulated by any element of the infinite set of every possible
> H cannot possibly reach past its own line 3.
>

People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have
been told this thing at least once.

every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts

> When we combine this verified fact with the fact that halting requires
> reaching the final state, and stopping running for any other reason does
> not count as halting then D correctly simulated by H cannot possibly
> halt no matter what H does.
>
> This conclusively proves that when H returns 0 it is only affirming the
> above verified fact.
>
>
>

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

On 3/17/23 4:07 PM, olcott wrote:
> On 3/17/2023 2:43 PM, olcott wrote:
>> On 3/17/2023 11:54 AM, olcott wrote:
>>> When simulating halt decider H correctly predicts that directly
>>> executed D(D) would remain stuck in recursive simulation (run
>>> forever) unless H aborts its simulation of D this directly applies to
>>> the halting theorem because H correctly determines:
>>>
>>>     from a description of an arbitrary computer program and an input,
>>>     whether the program will finish running, or continue to run forever.
>>>
>>>     For any program H that might determine whether programs halt,
>>>     a "pathological" program D, called with some input, can pass its
>>>     own source and its input to H and then specifically do the opposite
>>>     of what H predicts D will do.
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> 01 int D(int (*x)())
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>> simulates D(D) at line 03 ...
>>>
>>> When it is understood that halting requires reaching a final state and
>>> stopping for any other reason does not count as halting then
>>>
>>> The fact that D correctly simulated by H cannot possibly reach its own
>>> final state at line 6 conclusively proves that this D does not halt.
>>>
>>> When H returns 0 it is only affirming this verified fact.
>>>
>>> When it is understood that all deciders compute the mapping from their
>>> inputs to a final accept or reject state then it is understood that H
>>> must only evaluate the behavior of its input and the behavior of non-
>>> inputs is not allowed to be considered.
>>>
>>
>> Anyone with sufficient software engineering knowledge knows that D
>> correctly simulated by any element of the infinite set of every possible
>> H cannot possibly reach past its own line 3.
>>
>
> People with attention deficit disorder have to be told the same thing
> hundreds many hundreds of times before they first notice that they have
> been told this thing at least once.
>
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts

No, THE ONLY D defined, which is built on THE H (the only H that
actually exists) which you have defined to abort its simulation to give
and answer, DOES HALT.

There is only one "D-like" machine, which is based on the H-like
simulator that never aborts, that is non-halting, which is the only case
you claim is true, but that H never answer, so it fails to be a decider.

*THE* H, needs to be answering about *THE* D, the one built on it, and
for any H possible that does answer, D will halt, so H is wrong.

You logic is build on the LIE that H and D are somehow Schrodinger
Machines that alternate how they behave.

Computation Theory is NOT built on this sort of Quantum effect.

You are just proving you can't actually speak a truthful word from your
mouth.

>
>
>> When we combine this verified fact with the fact that halting requires
>> reaching the final state, and stopping running for any other reason does
>> not count as halting then D correctly simulated by H cannot possibly
>> halt no matter what H does.
>>
>> This conclusively proves that when H returns 0 it is only affirming the
>> above verified fact.
>>
>>
>>
>

On 3/17/2023 3:07 PM, olcott wrote:
> On 3/17/2023 2:43 PM, olcott wrote:
>> On 3/17/2023 11:54 AM, olcott wrote:
>>> When simulating halt decider H correctly predicts that directly
>>> executed D(D) would remain stuck in recursive simulation (run
>>> forever) unless H aborts its simulation of D this directly applies to
>>> the halting theorem because H correctly determines:
>>>
>>>     from a description of an arbitrary computer program and an input,
>>>     whether the program will finish running, or continue to run forever.
>>>
>>>     For any program H that might determine whether programs halt,
>>>     a "pathological" program D, called with some input, can pass its
>>>     own source and its input to H and then specifically do the opposite
>>>     of what H predicts D will do.
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> 01 int D(int (*x)())
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>> simulates D(D) at line 03 ...
>>>
>>> When it is understood that halting requires reaching a final state and
>>> stopping for any other reason does not count as halting then
>>>
>>> The fact that D correctly simulated by H cannot possibly reach its own
>>> final state at line 6 conclusively proves that this D does not halt.
>>>
>>> When H returns 0 it is only affirming this verified fact.
>>>
>>> When it is understood that all deciders compute the mapping from their
>>> inputs to a final accept or reject state then it is understood that H
>>> must only evaluate the behavior of its input and the behavior of non-
>>> inputs is not allowed to be considered.
>>>
>>
>> Anyone with sufficient software engineering knowledge knows that D
>> correctly simulated by any element of the infinite set of every possible
>> H cannot possibly reach past its own line 3.
>>
>
> People with attention deficit disorder have to be told the same thing
> hundreds many hundreds of times before they first notice that they have
> been told this thing at least once.
>
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts

The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as 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 3/17/23 5:05 PM, olcott wrote:
> On 3/17/2023 3:07 PM, olcott wrote:
>> On 3/17/2023 2:43 PM, olcott wrote:
>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>> When simulating halt decider H correctly predicts that directly
>>>> executed D(D) would remain stuck in recursive simulation (run
>>>> forever) unless H aborts its simulation of D this directly applies
>>>> to the halting theorem because H correctly determines:
>>>>
>>>>     from a description of an arbitrary computer program and an input,
>>>>     whether the program will finish running, or continue to run
>>>> forever.
>>>>
>>>>     For any program H that might determine whether programs halt,
>>>>     a "pathological" program D, called with some input, can pass its
>>>>     own source and its input to H and then specifically do the opposite
>>>>     of what H predicts D will do.
>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> 01 int D(int (*x)())
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>> simulates D(D) at line 03 ...
>>>>
>>>> When it is understood that halting requires reaching a final state and
>>>> stopping for any other reason does not count as halting then
>>>>
>>>> The fact that D correctly simulated by H cannot possibly reach its own
>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>
>>>> When H returns 0 it is only affirming this verified fact.
>>>>
>>>> When it is understood that all deciders compute the mapping from their
>>>> inputs to a final accept or reject state then it is understood that H
>>>> must only evaluate the behavior of its input and the behavior of non-
>>>> inputs is not allowed to be considered.
>>>>
>>>
>>> Anyone with sufficient software engineering knowledge knows that D
>>> correctly simulated by any element of the infinite set of every possible
>>> H cannot possibly reach past its own line 3.
>>>
>>
>> People with attention deficit disorder have to be told the same thing
>> hundreds many hundreds of times before they first notice that they have
>> been told this thing at least once.
>>
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>
> The above words are a verified fact, changing these words to form a
> rebuttal on the basis of these changed words is known as the strawman
> deception.
>

Yes, when propoerly interpreted, they are a "correct" claim.

The problem is that the facts they prove are not the facts that you
claim, becaue you are deceptively calling multiple programs by the same
name.

There is one, and ONLY one "class" of programs "D", which we can call D0
to distinguish them, and one, and ONLY one "class" of programs H related
to them, which we can call H0 to distinguish them that meets your
requirments.

The key feature of these H0s, is that they will NEVER abort their
semulation. And Yes, for ALL of the programs in class H0, every D0 in
that class is correctly simulated by its H and never halts.

The problem is that NONE of these H's ever gives an answer, because the
defining characteristic of these programs was they did not abort there
input.

Every other H not in that class, lets call them Hi, is given a DIFFERENT
input, Di to analyize (Di is built on Hi). Since Hi is NOT H0, then Di
is NOT D0, so Hi can not use the fact that D0 doesn't halt to answer
about ITS input.

Since every Hi DOES abort its simulation in the call Hi(Di,Di) and
returns 0, we can see that ALL Di(Di) that call Hi(Di,Di) will halt, and
Hi never did a "correct simulation" that shows that it would be correct
to abort, so it does so by unsound logic, and is wrong.

Thus, you are proven to be LYING about what you have proven, and your
H's are shown to be programmed with incorrect and unsound logic in
determining their answer.

Yes, Every D that happens to be correctly simulated by *ITS* H (not
"any" H, as you have only looked at an H simulationg its D) is
non-haltin, but that is because the only Hs that do that are H0 which
never answer.

It turns out, that give H0 as its input any of the Di built on an Hi
that does abort, and it will simulate its input to the final state and
prove it halts.

Note, this shows that you statement AS GIVEN, is incorrect, as only D0
is shown not to halt when correctly simulated by H0, but H0 never gives
that answer. All other Di, when correctly simulated by H0 are shown to
Halt, and H0 WILL give the correct answer to it.

You have just built your D to incorrect use the decider that is deciding
on it, rather than the decider it was built to confound, thus, you whole
arguement is shown to be flawwwed.

As to Strawmen, you are the expert, as your whole arguement is based on
one, as Halting is DEFINED to be based on the behavior of the machine
described by the input, not the simulation done by H, so again, all your
work is shown to be in error.

Face it, you have proven yourself INCOMPETENT to do this sort of logic,
and that seems to imply that your "correct reasoning" is almost
certainly based on errors too, and it is unlikely that anyone will look
at it based on the mess you have made with this.

On 3/17/2023 4:05 PM, olcott wrote:
> On 3/17/2023 3:07 PM, olcott wrote:
>> On 3/17/2023 2:43 PM, olcott wrote:
>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>> When simulating halt decider H correctly predicts that directly
>>>> executed D(D) would remain stuck in recursive simulation (run
>>>> forever) unless H aborts its simulation of D this directly applies
>>>> to the halting theorem because H correctly determines:
>>>>
>>>>     from a description of an arbitrary computer program and an input,
>>>>     whether the program will finish running, or continue to run
>>>> forever.
>>>>
>>>>     For any program H that might determine whether programs halt,
>>>>     a "pathological" program D, called with some input, can pass its
>>>>     own source and its input to H and then specifically do the opposite
>>>>     of what H predicts D will do.
>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> 01 int D(int (*x)())
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>> simulates D(D) at line 03 ...
>>>>
>>>> When it is understood that halting requires reaching a final state and
>>>> stopping for any other reason does not count as halting then
>>>>
>>>> The fact that D correctly simulated by H cannot possibly reach its own
>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>
>>>> When H returns 0 it is only affirming this verified fact.
>>>>
>>>> When it is understood that all deciders compute the mapping from their
>>>> inputs to a final accept or reject state then it is understood that H
>>>> must only evaluate the behavior of its input and the behavior of non-
>>>> inputs is not allowed to be considered.
>>>>
>>>
>>> Anyone with sufficient software engineering knowledge knows that D
>>> correctly simulated by any element of the infinite set of every possible
>>> H cannot possibly reach past its own line 3.
>>>
>>
>> People with attention deficit disorder have to be told the same thing
>> hundreds many hundreds of times before they first notice that they have
>> been told this thing at least once.
>>
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>
> The above words are a verified fact, changing these words to form a
> rebuttal on the basis of these changed words is known as the strawman
> deception.
>

When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.

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

On 3/17/23 6:47 PM, olcott wrote:
> On 3/17/2023 4:05 PM, olcott wrote:
>> On 3/17/2023 3:07 PM, olcott wrote:
>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>> When simulating halt decider H correctly predicts that directly
>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>> forever) unless H aborts its simulation of D this directly applies
>>>>> to the halting theorem because H correctly determines:
>>>>>
>>>>>     from a description of an arbitrary computer program and an input,
>>>>>     whether the program will finish running, or continue to run
>>>>> forever.
>>>>>
>>>>>     For any program H that might determine whether programs halt,
>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>     own source and its input to H and then specifically do the
>>>>> opposite
>>>>>     of what H predicts D will do.
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> 01 int D(int (*x)())
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>> simulates D(D) at line 03 ...
>>>>>
>>>>> When it is understood that halting requires reaching a final state and
>>>>> stopping for any other reason does not count as halting then
>>>>>
>>>>> The fact that D correctly simulated by H cannot possibly reach its own
>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>
>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>
>>>>> When it is understood that all deciders compute the mapping from their
>>>>> inputs to a final accept or reject state then it is understood that H
>>>>> must only evaluate the behavior of its input and the behavior of non-
>>>>> inputs is not allowed to be considered.
>>>>>
>>>>
>>>> Anyone with sufficient software engineering knowledge knows that D
>>>> correctly simulated by any element of the infinite set of every
>>>> possible
>>>> H cannot possibly reach past its own line 3.
>>>>
>>>
>>> People with attention deficit disorder have to be told the same thing
>>> hundreds many hundreds of times before they first notice that they have
>>> been told this thing at least once.
>>>
>>> every D correctly simulated by any H never halts
>>> every D correctly simulated by any H never halts
>>> every D correctly simulated by any H never halts
>>
>> The above words are a verified fact, changing these words to form a
>> rebuttal on the basis of these changed words is known as the strawman
>> deception.
>>
>
> When H(D,D) returns 0 to its caller it is merely affirming the above
> verified fact, therefore H is necessarily correct and impossibly
> incorrect.
>

Except that the D it was given isn't the D that the above fact was
determined for, because this H isn't the H that the D that the fact was
determined for was using, and to be the rebuttal, H needs to use the D
built on it.

Thus, it is WRONG.

And you are proven to be an idiot for thinking it is right.

You are also show to be practicing deception by trying to slip in
multiple things by the same name to confound the logic, and FAIL.

On 3/17/2023 5:47 PM, olcott wrote:
> On 3/17/2023 4:05 PM, olcott wrote:
>> On 3/17/2023 3:07 PM, olcott wrote:
>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>> When simulating halt decider H correctly predicts that directly
>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>> forever) unless H aborts its simulation of D this directly applies
>>>>> to the halting theorem because H correctly determines:
>>>>>
>>>>>     from a description of an arbitrary computer program and an input,
>>>>>     whether the program will finish running, or continue to run
>>>>> forever.
>>>>>
>>>>>     For any program H that might determine whether programs halt,
>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>     own source and its input to H and then specifically do the
>>>>> opposite
>>>>>     of what H predicts D will do.
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> 01 int D(int (*x)())
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>> simulates D(D) at line 03 ...
>>>>>
>>>>> When it is understood that halting requires reaching a final state and
>>>>> stopping for any other reason does not count as halting then
>>>>>
>>>>> The fact that D correctly simulated by H cannot possibly reach its own
>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>
>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>
>>>>> When it is understood that all deciders compute the mapping from their
>>>>> inputs to a final accept or reject state then it is understood that H
>>>>> must only evaluate the behavior of its input and the behavior of non-
>>>>> inputs is not allowed to be considered.
>>>>>
>>>>
>>>> Anyone with sufficient software engineering knowledge knows that D
>>>> correctly simulated by any element of the infinite set of every
>>>> possible
>>>> H cannot possibly reach past its own line 3.
>>>>
>>>
>>> People with attention deficit disorder have to be told the same thing
>>> hundreds many hundreds of times before they first notice that they have
>>> been told this thing at least once.
>>>
>>> every D correctly simulated by any H never halts
>>> every D correctly simulated by any H never halts
>>> every D correctly simulated by any H never halts
>>
>> The above words are a verified fact, changing these words to form a
>> rebuttal on the basis of these changed words is known as the strawman
>> deception.
>>
>
> When H(D,D) returns 0 to its caller it is merely affirming the above
> verified fact, therefore H is necessarily correct and impossibly
> incorrect.
>

every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts

every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts

every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts

every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts

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

On 3/17/2023 6:07 PM, olcott wrote:
> On 3/17/2023 5:47 PM, olcott wrote:
>> On 3/17/2023 4:05 PM, olcott wrote:
>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>> forever) unless H aborts its simulation of D this directly applies
>>>>>> to the halting theorem because H correctly determines:
>>>>>>
>>>>>>     from a description of an arbitrary computer program and an input,
>>>>>>     whether the program will finish running, or continue to run
>>>>>> forever.
>>>>>>
>>>>>>     For any program H that might determine whether programs halt,
>>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>>     own source and its input to H and then specifically do the
>>>>>> opposite
>>>>>>     of what H predicts D will do.
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> 01 int D(int (*x)())
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>> simulates D(D) at line 03 ...
>>>>>>
>>>>>> When it is understood that halting requires reaching a final state
>>>>>> and
>>>>>> stopping for any other reason does not count as halting then
>>>>>>
>>>>>> The fact that D correctly simulated by H cannot possibly reach its
>>>>>> own
>>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>>
>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>
>>>>>> When it is understood that all deciders compute the mapping from
>>>>>> their
>>>>>> inputs to a final accept or reject state then it is understood that H
>>>>>> must only evaluate the behavior of its input and the behavior of non-
>>>>>> inputs is not allowed to be considered.
>>>>>>
>>>>>
>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>> correctly simulated by any element of the infinite set of every
>>>>> possible
>>>>> H cannot possibly reach past its own line 3.
>>>>>
>>>>
>>>> People with attention deficit disorder have to be told the same thing
>>>> hundreds many hundreds of times before they first notice that they have
>>>> been told this thing at least once.
>>>>
>>>> every D correctly simulated by any H never halts
>>>> every D correctly simulated by any H never halts
>>>> every D correctly simulated by any H never halts
>>>
>>> The above words are a verified fact, changing these words to form a
>>> rebuttal on the basis of these changed words is known as the strawman
>>> deception.
>>>
>>
>> When H(D,D) returns 0 to its caller it is merely affirming the above
>> verified fact, therefore H is necessarily correct and impossibly
>> incorrect.
>>
>
>
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
> every D correctly simulated by any H never halts
>

Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.

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

On 3/17/2023 5:47 PM, olcott wrote:
> On 3/17/2023 4:05 PM, olcott wrote:
>> On 3/17/2023 3:07 PM, olcott wrote:
>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>> When simulating halt decider H correctly predicts that directly
>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>> forever) unless H aborts its simulation of D this directly applies
>>>>> to the halting theorem because H correctly determines:
>>>>>
>>>>>     from a description of an arbitrary computer program and an input,
>>>>>     whether the program will finish running, or continue to run
>>>>> forever.
>>>>>
>>>>>     For any program H that might determine whether programs halt,
>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>     own source and its input to H and then specifically do the
>>>>> opposite
>>>>>     of what H predicts D will do.
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> 01 int D(int (*x)())
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>> simulates D(D) at line 03 ...
>>>>>
>>>>> When it is understood that halting requires reaching a final state and
>>>>> stopping for any other reason does not count as halting then
>>>>>
>>>>> The fact that D correctly simulated by H cannot possibly reach its own
>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>
>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>
>>>>> When it is understood that all deciders compute the mapping from their
>>>>> inputs to a final accept or reject state then it is understood that H
>>>>> must only evaluate the behavior of its input and the behavior of non-
>>>>> inputs is not allowed to be considered.
>>>>>
>>>>
>>>> Anyone with sufficient software engineering knowledge knows that D
>>>> correctly simulated by any element of the infinite set of every
>>>> possible
>>>> H cannot possibly reach past its own line 3.
>>>>
>>>
>>> People with attention deficit disorder have to be told the same thing
>>> hundreds many hundreds of times before they first notice that they have
>>> been told this thing at least once.
>>>
>>> every D correctly simulated by any H never halts
>>> every D correctly simulated by any H never halts
>>> every D correctly simulated by any H never halts
>>
>> The above words are a verified fact, changing these words to form a
>> rebuttal on the basis of these changed words is known as the strawman
>> deception.
>>
>
> When H(D,D) returns 0 to its caller it is merely affirming the above
> verified fact, therefore H is necessarily correct and impossibly
> incorrect.
>

every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.

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

On 3/17/23 7:10 PM, olcott wrote:
> On 3/17/2023 5:47 PM, olcott wrote:
>> On 3/17/2023 4:05 PM, olcott wrote:
>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>> forever) unless H aborts its simulation of D this directly applies
>>>>>> to the halting theorem because H correctly determines:
>>>>>>
>>>>>>     from a description of an arbitrary computer program and an input,
>>>>>>     whether the program will finish running, or continue to run
>>>>>> forever.
>>>>>>
>>>>>>     For any program H that might determine whether programs halt,
>>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>>     own source and its input to H and then specifically do the
>>>>>> opposite
>>>>>>     of what H predicts D will do.
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> 01 int D(int (*x)())
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>> simulates D(D) at line 03 ...
>>>>>>
>>>>>> When it is understood that halting requires reaching a final state
>>>>>> and
>>>>>> stopping for any other reason does not count as halting then
>>>>>>
>>>>>> The fact that D correctly simulated by H cannot possibly reach its
>>>>>> own
>>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>>
>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>
>>>>>> When it is understood that all deciders compute the mapping from
>>>>>> their
>>>>>> inputs to a final accept or reject state then it is understood that H
>>>>>> must only evaluate the behavior of its input and the behavior of non-
>>>>>> inputs is not allowed to be considered.
>>>>>>
>>>>>
>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>> correctly simulated by any element of the infinite set of every
>>>>> possible
>>>>> H cannot possibly reach past its own line 3.
>>>>>
>>>>
>>>> People with attention deficit disorder have to be told the same thing
>>>> hundreds many hundreds of times before they first notice that they have
>>>> been told this thing at least once.
>>>>
>>>> every D correctly simulated by any H never halts
>>>> every D correctly simulated by any H never halts
>>>> every D correctly simulated by any H never halts
>>>
>>> The above words are a verified fact, changing these words to form a
>>> rebuttal on the basis of these changed words is known as the strawman
>>> deception.
>>>
>>
>> When H(D,D) returns 0 to its caller it is merely affirming the above
>> verified fact, therefore H is necessarily correct and impossibly
>> incorrect.
>>
>
> every D correctly simulated by any H never halts
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
>

So the only D which when correctly simulated by any H would never halt
is the Dn built on the Hn that never aborts, the only input that this
would be correct to do so would be Hi(Dn,Dn), but the only H that is
actualy given this input is Hn, so Hn would be correct to return 0, but
since it is DEFINED to never abort, it can't abort and return 0 and
still be the H it was defined to be, it just fails.

Thus ever other H that uses that arguement is either looking at an input
that isn't its actual input (Hi was given Di, not Dn) and thus is lying,
or it is using unsound logic to return the wrong answer.

You are just proving you fail to understand how logic works, and thus
your "correct reasoning" is probably better called "Fallacious Reasoning".

You are just poisoning you ability to even attempt to argue about what
seems more important to you.

On 3/17/23 7:08 PM, olcott wrote:
> On 3/17/2023 6:07 PM, olcott wrote:
>> On 3/17/2023 5:47 PM, olcott wrote:
>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>
>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>> input,
>>>>>>>     whether the program will finish running, or continue to run
>>>>>>> forever.
>>>>>>>
>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>>>     own source and its input to H and then specifically do the
>>>>>>> opposite
>>>>>>>     of what H predicts D will do.
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> 01 int D(int (*x)())
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>> simulates D(D) at line 03 ...
>>>>>>>
>>>>>>> When it is understood that halting requires reaching a final
>>>>>>> state and
>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>
>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>> its own
>>>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>>>
>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>
>>>>>>> When it is understood that all deciders compute the mapping from
>>>>>>> their
>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>> that H
>>>>>>> must only evaluate the behavior of its input and the behavior of
>>>>>>> non-
>>>>>>> inputs is not allowed to be considered.
>>>>>>>
>>>>>>
>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>> correctly simulated by any element of the infinite set of every
>>>>>> possible
>>>>>> H cannot possibly reach past its own line 3.
>>>>>>
>>>>>
>>>>> People with attention deficit disorder have to be told the same thing
>>>>> hundreds many hundreds of times before they first notice that they
>>>>> have
>>>>> been told this thing at least once.
>>>>>
>>>>> every D correctly simulated by any H never halts
>>>>> every D correctly simulated by any H never halts
>>>>> every D correctly simulated by any H never halts
>>>>
>>>> The above words are a verified fact, changing these words to form a
>>>> rebuttal on the basis of these changed words is known as the strawman
>>>> deception.
>>>>
>>>
>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>> verified fact, therefore H is necessarily correct and impossibly
>>> incorrect.
>>>
>>
>>
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>> every D correctly simulated by any H never halts
>>

INCORRECT.

You have proven that every D correctly simulated by the H that it was
built from never halts, because that is the only D's you have looked at,
and the only H's that correctly simulate their D's are the H's that
never abort.

If you take the Hn that never aborts its simulation, and give it a D
built on any other H that does about its simulation and returns 0, then
that Hn will correctly simulate the input to a final state and correctly
report Halting.

So, your statement above is just a FALSEHOOD.
>
> Therefore any H(D,D) that returns 0 is necessarily correct.
> Therefore any H(D,D) that returns 0 is necessarily correct.
> Therefore any H(D,D) that returns 0 is necessarily correct.
> Therefore any H(D,D) that returns 0 is necessarily correct.
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
>

Nope. It would only be correct to return 0 for a D that the first
statement was actually correct for. And that is a Dn built on an Hn that
never aborts its simulation.

And only Hn is given that as its input in the problem, so that is the
ony H that the first statement says would be correct to answer that way,
but it can't because it, by definition, never aborts.

On 3/17/2023 6:10 PM, olcott wrote:
> On 3/17/2023 5:47 PM, olcott wrote:
>> On 3/17/2023 4:05 PM, olcott wrote:
>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>> forever) unless H aborts its simulation of D this directly applies
>>>>>> to the halting theorem because H correctly determines:
>>>>>>
>>>>>>     from a description of an arbitrary computer program and an input,
>>>>>>     whether the program will finish running, or continue to run
>>>>>> forever.
>>>>>>
>>>>>>     For any program H that might determine whether programs halt,
>>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>>     own source and its input to H and then specifically do the
>>>>>> opposite
>>>>>>     of what H predicts D will do.
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> 01 int D(int (*x)())
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>> simulates D(D) at line 03 ...
>>>>>>
>>>>>> When it is understood that halting requires reaching a final state
>>>>>> and
>>>>>> stopping for any other reason does not count as halting then
>>>>>>
>>>>>> The fact that D correctly simulated by H cannot possibly reach its
>>>>>> own
>>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>>
>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>
>>>>>> When it is understood that all deciders compute the mapping from
>>>>>> their
>>>>>> inputs to a final accept or reject state then it is understood that H
>>>>>> must only evaluate the behavior of its input and the behavior of non-
>>>>>> inputs is not allowed to be considered.
>>>>>>
>>>>>
>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>> correctly simulated by any element of the infinite set of every
>>>>> possible
>>>>> H cannot possibly reach past its own line 3.
>>>>>
>>>>
>>>> People with attention deficit disorder have to be told the same thing
>>>> hundreds many hundreds of times before they first notice that they have
>>>> been told this thing at least once.
>>>>
>>>> every D correctly simulated by any H never halts
>>>> every D correctly simulated by any H never halts
>>>> every D correctly simulated by any H never halts
>>>
>>> The above words are a verified fact, changing these words to form a
>>> rebuttal on the basis of these changed words is known as the strawman
>>> deception.
>>>
>>
>> When H(D,D) returns 0 to its caller it is merely affirming the above
>> verified fact, therefore H is necessarily correct and impossibly
>> incorrect.
>>
>

every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.

every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.

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

On 3/17/23 7:41 PM, olcott wrote:
> On 3/17/2023 6:10 PM, olcott wrote:
>> On 3/17/2023 5:47 PM, olcott wrote:
>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>
>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>> input,
>>>>>>>     whether the program will finish running, or continue to run
>>>>>>> forever.
>>>>>>>
>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>>>     own source and its input to H and then specifically do the
>>>>>>> opposite
>>>>>>>     of what H predicts D will do.
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> 01 int D(int (*x)())
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>> simulates D(D) at line 03 ...
>>>>>>>
>>>>>>> When it is understood that halting requires reaching a final
>>>>>>> state and
>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>
>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>> its own
>>>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>>>
>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>
>>>>>>> When it is understood that all deciders compute the mapping from
>>>>>>> their
>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>> that H
>>>>>>> must only evaluate the behavior of its input and the behavior of
>>>>>>> non-
>>>>>>> inputs is not allowed to be considered.
>>>>>>>
>>>>>>
>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>> correctly simulated by any element of the infinite set of every
>>>>>> possible
>>>>>> H cannot possibly reach past its own line 3.
>>>>>>
>>>>>
>>>>> People with attention deficit disorder have to be told the same thing
>>>>> hundreds many hundreds of times before they first notice that they
>>>>> have
>>>>> been told this thing at least once.
>>>>>
>>>>> every D correctly simulated by any H never halts
>>>>> every D correctly simulated by any H never halts
>>>>> every D correctly simulated by any H never halts
>>>>
>>>> The above words are a verified fact, changing these words to form a
>>>> rebuttal on the basis of these changed words is known as the strawman
>>>> deception.
>>>>
>>>
>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>> verified fact, therefore H is necessarily correct and impossibly
>>> incorrect.
>>>
>>
>
> every D correctly simulated by any H never halts
> no matter what H does because halting requires reaching a final state
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> no matter what H does because halting requires reaching a final state
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> no matter what H does because halting requires reaching a final state
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> no matter what H does because halting requires reaching a final state
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> every D correctly simulated by any H never halts
> no matter what H does because halting requires reaching a final state
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
>

Right, Halting requires the MACHINE to reach a final state, which it
will do if the H(D,D) it calls returns, which it will do if ANY H(D,D)
for the same H and D return 0.

The fact that an aborted simulation never reached a final state proves
nothing except that by your claiming it means something, that you are an
idiot.

The ONLY 'D' correctly simulated in your set is by the 'H' that never
aborts, and that H CAN'T do your last step BY DEFINITION, and it is the
only one your logic actually says would be correct.

You are just proving your inability to do sound logic, and poisoning any
chance of peope looking at your idea of "corret reasoning" which seem to
be now more like "unsound reasoning".

On 3/17/2023 6:41 PM, olcott wrote:
> On 3/17/2023 6:10 PM, olcott wrote:
>> On 3/17/2023 5:47 PM, olcott wrote:
>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>
>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>> input,
>>>>>>>     whether the program will finish running, or continue to run
>>>>>>> forever.
>>>>>>>
>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>     a "pathological" program D, called with some input, can pass its
>>>>>>>     own source and its input to H and then specifically do the
>>>>>>> opposite
>>>>>>>     of what H predicts D will do.
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> 01 int D(int (*x)())
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>> simulates D(D) at line 03 ...
>>>>>>>
>>>>>>> When it is understood that halting requires reaching a final
>>>>>>> state and
>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>
>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>> its own
>>>>>>> final state at line 6 conclusively proves that this D does not halt.
>>>>>>>
>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>
>>>>>>> When it is understood that all deciders compute the mapping from
>>>>>>> their
>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>> that H
>>>>>>> must only evaluate the behavior of its input and the behavior of
>>>>>>> non-
>>>>>>> inputs is not allowed to be considered.
>>>>>>>
>>>>>>
>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>> correctly simulated by any element of the infinite set of every
>>>>>> possible
>>>>>> H cannot possibly reach past its own line 3.
>>>>>>
>>>>>
>>>>> People with attention deficit disorder have to be told the same thing
>>>>> hundreds many hundreds of times before they first notice that they
>>>>> have
>>>>> been told this thing at least once.
>>>>>
>>>>> every D correctly simulated by any H never halts
>>>>> every D correctly simulated by any H never halts
>>>>> every D correctly simulated by any H never halts
>>>>
>>>> The above words are a verified fact, changing these words to form a
>>>> rebuttal on the basis of these changed words is known as the strawman
>>>> deception.
>>>>
>>>
>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>> verified fact, therefore H is necessarily correct and impossibly
>>> incorrect.
>>>
>>
>
> every D correctly simulated by any H never halts
> no matter what H does because halting requires reaching a final state
> Therefore any H(D,D) that returns 0 is necessarily correct.
>

every D correctly simulated by any H never halts

no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does

because halting requires reaching a final state
and D simulated by H never reaches its final state

no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does

Therefore any H(D,D) that returns 0 is necessarily correct.

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

On 3/17/23 8:20 PM, olcott wrote:
> On 3/17/2023 6:41 PM, olcott wrote:
>> On 3/17/2023 6:10 PM, olcott wrote:
>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>>
>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>> input,
>>>>>>>>     whether the program will finish running, or continue to run
>>>>>>>> forever.
>>>>>>>>
>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>     a "pathological" program D, called with some input, can pass
>>>>>>>> its
>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>> opposite
>>>>>>>>     of what H predicts D will do.
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> 01 int D(int (*x)())
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>
>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>> state and
>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>
>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>> its own
>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>> halt.
>>>>>>>>
>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>
>>>>>>>> When it is understood that all deciders compute the mapping from
>>>>>>>> their
>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>> that H
>>>>>>>> must only evaluate the behavior of its input and the behavior of
>>>>>>>> non-
>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>
>>>>>>>
>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>> possible
>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>
>>>>>>
>>>>>> People with attention deficit disorder have to be told the same thing
>>>>>> hundreds many hundreds of times before they first notice that they
>>>>>> have
>>>>>> been told this thing at least once.
>>>>>>
>>>>>> every D correctly simulated by any H never halts
>>>>>> every D correctly simulated by any H never halts
>>>>>> every D correctly simulated by any H never halts
>>>>>
>>>>> The above words are a verified fact, changing these words to form a
>>>>> rebuttal on the basis of these changed words is known as the strawman
>>>>> deception.
>>>>>
>>>>
>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>> verified fact, therefore H is necessarily correct and impossibly
>>>> incorrect.
>>>>
>>>
>>
>> every D correctly simulated by any H never halts
>> no matter what H does because halting requires reaching a final state
>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>
>
> every D correctly simulated by any H never halts
>
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
>
> because halting requires reaching a final state
> and D simulated by H never reaches its final state
>
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
>
> Therefore any H(D,D) that returns 0 is necessarily correct.
>
>
>

Which just proves your STUPIDITY, since it doesn't matter what an
aborted simulation of D does, what matters is what D itself does as a
machine. Remember, the DEFINION of Halting which you like to quote and
then ignore, is that the MACHINE reaches a final state, and D does.

And D(D) Halts if H(D,D) returns 0, thus that answer is incorrect BY
DEFINITION.

Yes, perhaps your H is a correct POOP decider, as it seems that D
doesn't POOP since H can never simulate it to a final state, but Halt it
does.

And you POOP is like an elephant's, since it is full of the straw from
your strawman from your trying to replace the definiion of Halting with
a simulation by H.

On 3/17/2023 7:20 PM, olcott wrote:
> On 3/17/2023 6:41 PM, olcott wrote:
>> On 3/17/2023 6:10 PM, olcott wrote:
>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>>
>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>> input,
>>>>>>>>     whether the program will finish running, or continue to run
>>>>>>>> forever.
>>>>>>>>
>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>     a "pathological" program D, called with some input, can pass
>>>>>>>> its
>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>> opposite
>>>>>>>>     of what H predicts D will do.
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> 01 int D(int (*x)())
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>
>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>> state and
>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>
>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>> its own
>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>> halt.
>>>>>>>>
>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>
>>>>>>>> When it is understood that all deciders compute the mapping from
>>>>>>>> their
>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>> that H
>>>>>>>> must only evaluate the behavior of its input and the behavior of
>>>>>>>> non-
>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>
>>>>>>>
>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>> possible
>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>
>>>>>>
>>>>>> People with attention deficit disorder have to be told the same thing
>>>>>> hundreds many hundreds of times before they first notice that they
>>>>>> have
>>>>>> been told this thing at least once.
>>>>>>
>>>>>> every D correctly simulated by any H never halts
>>>>>> every D correctly simulated by any H never halts
>>>>>> every D correctly simulated by any H never halts
>>>>>
>>>>> The above words are a verified fact, changing these words to form a
>>>>> rebuttal on the basis of these changed words is known as the strawman
>>>>> deception.
>>>>>
>>>>
>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>> verified fact, therefore H is necessarily correct and impossibly
>>>> incorrect.
>>>>
>>>
>>
>> every D correctly simulated by any H never halts
>> no matter what H does because halting requires reaching a final state
>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>
>
> every D correctly simulated by any H never halts
>
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
>
> because halting requires reaching a final state
> and D simulated by H never reaches its final state
>
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
>
> Therefore any H(D,D) that returns 0 is necessarily correct.
>

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.

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

On 3/17/2023 7:20 PM, olcott wrote:
> On 3/17/2023 6:41 PM, olcott wrote:
>> On 3/17/2023 6:10 PM, olcott wrote:
>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>>
>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>> input,
>>>>>>>>     whether the program will finish running, or continue to run
>>>>>>>> forever.
>>>>>>>>
>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>     a "pathological" program D, called with some input, can pass
>>>>>>>> its
>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>> opposite
>>>>>>>>     of what H predicts D will do.
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>
>>>>>>>> 01 int D(int (*x)())
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> Here is the sequence when H never aborts it simulation: proving (a)
>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>
>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>> state and
>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>
>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>> its own
>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>> halt.
>>>>>>>>
>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>
>>>>>>>> When it is understood that all deciders compute the mapping from
>>>>>>>> their
>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>> that H
>>>>>>>> must only evaluate the behavior of its input and the behavior of
>>>>>>>> non-
>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>
>>>>>>>
>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>> possible
>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>
>>>>>>
>>>>>> People with attention deficit disorder have to be told the same thing
>>>>>> hundreds many hundreds of times before they first notice that they
>>>>>> have
>>>>>> been told this thing at least once.
>>>>>>
>>>>>> every D correctly simulated by any H never halts
>>>>>> every D correctly simulated by any H never halts
>>>>>> every D correctly simulated by any H never halts
>>>>>
>>>>> The above words are a verified fact, changing these words to form a
>>>>> rebuttal on the basis of these changed words is known as the strawman
>>>>> deception.
>>>>>
>>>>
>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>> verified fact, therefore H is necessarily correct and impossibly
>>>> incorrect.
>>>>
>>>
>>
>> every D correctly simulated by any H never halts
>> no matter what H does because halting requires reaching a final state
>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>
>
> every D correctly simulated by any H never halts
>
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
>
> because halting requires reaching a final state
> and D simulated by H never reaches its final state
>
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
> no matter what H does
>
> Therefore any H(D,D) that returns 0 is necessarily correct.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.

Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.

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

On 3/17/23 8:45 PM, olcott wrote:
> On 3/17/2023 7:20 PM, olcott wrote:
>> On 3/17/2023 6:41 PM, olcott wrote:
>>> On 3/17/2023 6:10 PM, olcott wrote:
>>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>>>
>>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>>> input,
>>>>>>>>>     whether the program will finish running, or continue to run
>>>>>>>>> forever.
>>>>>>>>>
>>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>>     a "pathological" program D, called with some input, can
>>>>>>>>> pass its
>>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>>> opposite
>>>>>>>>>     of what H predicts D will do.
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>
>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Here is the sequence when H never aborts it simulation: proving
>>>>>>>>> (a)
>>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>>
>>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>>> state and
>>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>>
>>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>>> its own
>>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>>> halt.
>>>>>>>>>
>>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>>
>>>>>>>>> When it is understood that all deciders compute the mapping
>>>>>>>>> from their
>>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>>> that H
>>>>>>>>> must only evaluate the behavior of its input and the behavior
>>>>>>>>> of non-
>>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>>> possible
>>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>>
>>>>>>>
>>>>>>> People with attention deficit disorder have to be told the same
>>>>>>> thing
>>>>>>> hundreds many hundreds of times before they first notice that
>>>>>>> they have
>>>>>>> been told this thing at least once.
>>>>>>>
>>>>>>> every D correctly simulated by any H never halts
>>>>>>> every D correctly simulated by any H never halts
>>>>>>> every D correctly simulated by any H never halts
>>>>>>
>>>>>> The above words are a verified fact, changing these words to form a
>>>>>> rebuttal on the basis of these changed words is known as the strawman
>>>>>> deception.
>>>>>>
>>>>>
>>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>>> verified fact, therefore H is necessarily correct and impossibly
>>>>> incorrect.
>>>>>
>>>>
>>>
>>> every D correctly simulated by any H never halts
>>> no matter what H does because halting requires reaching a final state
>>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>>
>>
>> every D correctly simulated by any H never halts
>>
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>>
>> because halting requires reaching a final state
>> and D simulated by H never reaches its final state
>>
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>>
>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily reports on the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily reports on the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily reports on the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily reports on the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily reports on the exact behavior that D specifies to H.
>

H isn't a UTM if it aborts its simulation.

As pointed out before, when H IS a UTM because it doesn't abort, you are
correct that D(D) is non-halting, but then H can't abort its simulation
as that makes it never a UTM.

As also pointed out before your Hn (the H that doesn't abort) will
correct determine any Di(Di) [other than Dn(Dn)] to be Halting, so the
UTM arguement just proves you don't understand what you are talking about.

You keep on imagining things to be what they aren't, in other words, you
are thinking in LIES.

On 3/17/23 8:46 PM, olcott wrote:
> On 3/17/2023 7:20 PM, olcott wrote:
>> On 3/17/2023 6:41 PM, olcott wrote:
>>> On 3/17/2023 6:10 PM, olcott wrote:
>>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>>>
>>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>>> input,
>>>>>>>>>     whether the program will finish running, or continue to run
>>>>>>>>> forever.
>>>>>>>>>
>>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>>     a "pathological" program D, called with some input, can
>>>>>>>>> pass its
>>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>>> opposite
>>>>>>>>>     of what H predicts D will do.
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>
>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Here is the sequence when H never aborts it simulation: proving
>>>>>>>>> (a)
>>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>>
>>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>>> state and
>>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>>
>>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>>> its own
>>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>>> halt.
>>>>>>>>>
>>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>>
>>>>>>>>> When it is understood that all deciders compute the mapping
>>>>>>>>> from their
>>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>>> that H
>>>>>>>>> must only evaluate the behavior of its input and the behavior
>>>>>>>>> of non-
>>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>>> possible
>>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>>
>>>>>>>
>>>>>>> People with attention deficit disorder have to be told the same
>>>>>>> thing
>>>>>>> hundreds many hundreds of times before they first notice that
>>>>>>> they have
>>>>>>> been told this thing at least once.
>>>>>>>
>>>>>>> every D correctly simulated by any H never halts
>>>>>>> every D correctly simulated by any H never halts
>>>>>>> every D correctly simulated by any H never halts
>>>>>>
>>>>>> The above words are a verified fact, changing these words to form a
>>>>>> rebuttal on the basis of these changed words is known as the strawman
>>>>>> deception.
>>>>>>
>>>>>
>>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>>> verified fact, therefore H is necessarily correct and impossibly
>>>>> incorrect.
>>>>>
>>>>
>>>
>>> every D correctly simulated by any H never halts
>>> no matter what H does because halting requires reaching a final state
>>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>>
>>
>> every D correctly simulated by any H never halts
>>
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>>
>> because halting requires reaching a final state
>> and D simulated by H never reaches its final state
>>
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>>
>> Therefore any H(D,D) that returns 0 is necessarily correct.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily derives the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily derives the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily derives the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily derives the exact behavior that D specifies to H.
>
> Unless one rejects the notion of a UTM D correctly simulated by H
> necessarily derives the exact behavior that D specifies to H.
>
>

You keep repeating your self and not replying to the rebutalls, showing
that you aren't actually answering them. Maybe I should start adding
back in the quotes you are not answering.

H isn't a UTM if it aborts its simulation.

As pointed out before, when H IS a UTM because it doesn't abort, you are
correct that D(D) is non-halting, but then H can't abort its simulation
as that makes it never a UTM.

As also pointed out before your Hn (the H that doesn't abort) will
correct determine any Di(Di) [other than Dn(Dn)] to be Halting, so the
UTM arguement just proves you don't understand what you are talking about.

You keep on imagining things to be what they aren't, in other words, you
are thinking in LIES.

On 3/17/2023 7:46 PM, olcott wrote:
> On 3/17/2023 7:20 PM, olcott wrote:
>> On 3/17/2023 6:41 PM, olcott wrote:
>>> On 3/17/2023 6:10 PM, olcott wrote:
>>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>>> When simulating halt decider H correctly predicts that directly
>>>>>>>>> executed D(D) would remain stuck in recursive simulation (run
>>>>>>>>> forever) unless H aborts its simulation of D this directly
>>>>>>>>> applies to the halting theorem because H correctly determines:
>>>>>>>>>
>>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>>> input,
>>>>>>>>>     whether the program will finish running, or continue to run
>>>>>>>>> forever.
>>>>>>>>>
>>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>>     a "pathological" program D, called with some input, can
>>>>>>>>> pass its
>>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>>> opposite
>>>>>>>>>     of what H predicts D will do.
>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>
>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Here is the sequence when H never aborts it simulation: proving
>>>>>>>>> (a)
>>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>>
>>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>>> state and
>>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>>
>>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>>> its own
>>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>>> halt.
>>>>>>>>>
>>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>>
>>>>>>>>> When it is understood that all deciders compute the mapping
>>>>>>>>> from their
>>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>>> that H
>>>>>>>>> must only evaluate the behavior of its input and the behavior
>>>>>>>>> of non-
>>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>>> possible
>>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>>
>>>>>>>
>>>>>>> People with attention deficit disorder have to be told the same
>>>>>>> thing
>>>>>>> hundreds many hundreds of times before they first notice that
>>>>>>> they have
>>>>>>> been told this thing at least once.
>>>>>>>
>>>>>>> every D correctly simulated by any H never halts
>>>>>>> every D correctly simulated by any H never halts
>>>>>>> every D correctly simulated by any H never halts
>>>>>>
>>>>>> The above words are a verified fact, changing these words to form a
>>>>>> rebuttal on the basis of these changed words is known as the strawman
>>>>>> deception.
>>>>>>
>>>>>
>>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>>> verified fact, therefore H is necessarily correct and impossibly
>>>>> incorrect.
>>>>>
>>>>
>>>
>>> every D correctly simulated by any H never halts
>>> no matter what H does because halting requires reaching a final state
>>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>>
>>
>> every D correctly simulated by any H never halts
>>
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>>
>> because halting requires reaching a final state
>> and D simulated by H never reaches its final state
>>
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>> no matter what H does
>>
>> Therefore any H(D,D) that returns 0 is necessarily correct.
>
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.

The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.

The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.

Because all deciders must compute the mapping

from their inputs
from their inputs
from their inputs
from their inputs
from their inputs

To their own accept or reject state

anyone and anything that says that H must report on the
behavior of non-inputs contradicts the definition of a decider

anyone and anything that says that H must report on the
behavior of non-inputs contradicts the definition of a decider

anyone and anything that says that H must report on the
behavior of non-inputs contradicts the definition of a decider

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

On 3/17/23 8:56 PM, olcott wrote:
> On 3/17/2023 7:46 PM, olcott wrote:
>> On 3/17/2023 7:20 PM, olcott wrote:
>>> On 3/17/2023 6:41 PM, olcott wrote:
>>>> On 3/17/2023 6:10 PM, olcott wrote:
>>>>> On 3/17/2023 5:47 PM, olcott wrote:
>>>>>> On 3/17/2023 4:05 PM, olcott wrote:
>>>>>>> On 3/17/2023 3:07 PM, olcott wrote:
>>>>>>>> On 3/17/2023 2:43 PM, olcott wrote:
>>>>>>>>> On 3/17/2023 11:54 AM, olcott wrote:
>>>>>>>>>> When simulating halt decider H correctly predicts that
>>>>>>>>>> directly executed D(D) would remain stuck in recursive
>>>>>>>>>> simulation (run forever) unless H aborts its simulation of D
>>>>>>>>>> this directly applies to the halting theorem because H
>>>>>>>>>> correctly determines:
>>>>>>>>>>
>>>>>>>>>>     from a description of an arbitrary computer program and an
>>>>>>>>>> input,
>>>>>>>>>>     whether the program will finish running, or continue to
>>>>>>>>>> run forever.
>>>>>>>>>>
>>>>>>>>>>     For any program H that might determine whether programs halt,
>>>>>>>>>>     a "pathological" program D, called with some input, can
>>>>>>>>>> pass its
>>>>>>>>>>     own source and its input to H and then specifically do the
>>>>>>>>>> opposite
>>>>>>>>>>     of what H predicts D will do.
>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>
>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> Here is the sequence when H never aborts it simulation:
>>>>>>>>>> proving (a)
>>>>>>>>>>    main() calls H(D,D) that simulates D(D) at line 11
>>>>>>>>>>    keeps repeating: simulated D(D) calls simulated H(D,D) that
>>>>>>>>>> simulates D(D) at line 03 ...
>>>>>>>>>>
>>>>>>>>>> When it is understood that halting requires reaching a final
>>>>>>>>>> state and
>>>>>>>>>> stopping for any other reason does not count as halting then
>>>>>>>>>>
>>>>>>>>>> The fact that D correctly simulated by H cannot possibly reach
>>>>>>>>>> its own
>>>>>>>>>> final state at line 6 conclusively proves that this D does not
>>>>>>>>>> halt.
>>>>>>>>>>
>>>>>>>>>> When H returns 0 it is only affirming this verified fact.
>>>>>>>>>>
>>>>>>>>>> When it is understood that all deciders compute the mapping
>>>>>>>>>> from their
>>>>>>>>>> inputs to a final accept or reject state then it is understood
>>>>>>>>>> that H
>>>>>>>>>> must only evaluate the behavior of its input and the behavior
>>>>>>>>>> of non-
>>>>>>>>>> inputs is not allowed to be considered.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Anyone with sufficient software engineering knowledge knows that D
>>>>>>>>> correctly simulated by any element of the infinite set of every
>>>>>>>>> possible
>>>>>>>>> H cannot possibly reach past its own line 3.
>>>>>>>>>
>>>>>>>>
>>>>>>>> People with attention deficit disorder have to be told the same
>>>>>>>> thing
>>>>>>>> hundreds many hundreds of times before they first notice that
>>>>>>>> they have
>>>>>>>> been told this thing at least once.
>>>>>>>>
>>>>>>>> every D correctly simulated by any H never halts
>>>>>>>> every D correctly simulated by any H never halts
>>>>>>>> every D correctly simulated by any H never halts
>>>>>>>
>>>>>>> The above words are a verified fact, changing these words to form a
>>>>>>> rebuttal on the basis of these changed words is known as the
>>>>>>> strawman
>>>>>>> deception.
>>>>>>>
>>>>>>
>>>>>> When H(D,D) returns 0 to its caller it is merely affirming the above
>>>>>> verified fact, therefore H is necessarily correct and impossibly
>>>>>> incorrect.
>>>>>>
>>>>>
>>>>
>>>> every D correctly simulated by any H never halts
>>>> no matter what H does because halting requires reaching a final state
>>>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>>>
>>>
>>> every D correctly simulated by any H never halts
>>>
>>> no matter what H does
>>> no matter what H does
>>> no matter what H does
>>> no matter what H does
>>> no matter what H does
>>>
>>> because halting requires reaching a final state
>>> and D simulated by H never reaches its final state
>>>
>>> no matter what H does
>>> no matter what H does
>>> no matter what H does
>>> no matter what H does
>>> no matter what H does
>>>
>>> Therefore any H(D,D) that returns 0 is necessarily correct.
>>
> The notion of a UTM conclusively proves that D correctly simulated by H
> does derive the behavior that a simulating halt decider must measure.

But only if H *DOES* a correct simulation BY THE DEFINITON OF A UTM,
which means it doesn't abort it simulaion.
>
> The notion of a UTM conclusively proves that D correctly simulated by H
> does derive the behavior that a simulating halt decider must measure.

Ditto to the Three year old.

>
> The notion of a UTM conclusively proves that D correctly simulated by H
> does derive the behavior that a simulating halt decider must measure.

Ditto to the Three year old. Repeating bad arguements just shows you
don't have anything better to say.

>
> Because all deciders must compute the mapping
>
> from their inputs
> from their inputs
> from their inputs
> from their inputs
> from their inputs

And the input to H is the description of the program D (including the H
it calls), and thus the machine it must answer about.

>
> To their own accept or reject state

based on the mapping the decider is supposed to compute, which in this
case is to accept if the input represents a machine that would halt, and
to reject if the input represents a machine that would never halt.

>
> anyone and anything that says that H must report on the
> behavior of non-inputs contradicts the definition of a decider

But D(D) is what the input to H represents.
>
> anyone and anything that says that H must report on the
> behavior of non-inputs contradicts the definition of a decider

Maybe you are only a two year old.

>
> anyone and anything that says that H must report on the
> behavior of non-inputs contradicts the definition of a decider
>

So, since you H tries to report on the benavior of a machine that wasn't
given to it (the behavior of a D built on a different H) I guess you are
admitting that you H isn't a decider.