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