On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 16:54 schreef olcott:
>> On 1/31/2024 7:04 AM, immibis wrote:
>>> On 1/31/24 01:56, olcott wrote:
>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>> I have already been completely through your idea with hundreds of
>>>>>> posts on another forum with someone else before I determined that
>>>>>> it is nonsense using set theory.
>>>>>
>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>
>>>>> The halting problem is to decide whether the execution sequence of
>>>>> a Turing machine/input pair is finite or infinite.
>>>>>
>>>>
>>>> Close but no cigar. No TM can take another TM as input, it
>>>> can only take finite strings as input.
>>>>
>>>> The halting problem is whether or not a finite string pair
>>>> (TM description and its input)
>>>>
>>>> *specifies a finite sequence of configurations*
>>>> *specifies a finite sequence of configurations*
>>>> *specifies a finite sequence of configurations*
>>>>
>>>
>>> The halting problem is whether or not you get a finite sequence of
>>> configurations when you execute the finite string pair according to
>>> Turing Machine rules and no other rules.
>>
>> *No that is a common misconception*
>> The halting problem is actually about computing the mapping
>> from an input finite string pair such the the first element of
>> this pair species behavior. It is the behavior that this finite
>> string specifies that must be reported on.
>>
>> When D does call H in recursive simulation such that D cannot
>> possibly stop running unless aborted the H is necessarily correct
>> to abort D and reject D as non-halting >
>> D correctly simulated by H cannot possibly reach the point in
>> its own execution trace where it does the opposite of whatever
>> value that H returns.
>>
>
> Olcott's H is of the Han type, because it aborts the simulation and

*PREMISE*
*When one understands that simulating termination analyzer H*
*is always correct to abort any simulation that cannot possibly*
*stop running unless aborted*

01 int D(ptr x) // ptr is pointer to int function
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 }

*IS LOGICALLY ENTAILED FROM PREMISE*
Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

This is true because halt deciders are requires to report on
the behavior that their input finite string specifies and
are not allowed to report on any other behavior.

It is proven above that D does specify recursive simulation
to H. Some idiots seem to believe that H must ignore the
call to H(D,D) from D.

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

Op 31.jan.2024 om 17:41 schreef olcott:
> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 16:54 schreef olcott:
>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>> On 1/31/24 01:56, olcott wrote:
>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>> I have already been completely through your idea with hundreds of
>>>>>>> posts on another forum with someone else before I determined that
>>>>>>> it is nonsense using set theory.
>>>>>>
>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>
>>>>>> The halting problem is to decide whether the execution sequence of
>>>>>> a Turing machine/input pair is finite or infinite.
>>>>>>
>>>>>
>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>> can only take finite strings as input.
>>>>>
>>>>> The halting problem is whether or not a finite string pair
>>>>> (TM description and its input)
>>>>>
>>>>> *specifies a finite sequence of configurations*
>>>>> *specifies a finite sequence of configurations*
>>>>> *specifies a finite sequence of configurations*
>>>>>
>>>>
>>>> The halting problem is whether or not you get a finite sequence of
>>>> configurations when you execute the finite string pair according to
>>>> Turing Machine rules and no other rules.
>>>
>>> *No that is a common misconception*
>>> The halting problem is actually about computing the mapping
>>> from an input finite string pair such the the first element of
>>> this pair species behavior. It is the behavior that this finite
>>> string specifies that must be reported on.
>>>
>>> When D does call H in recursive simulation such that D cannot
>>> possibly stop running unless aborted the H is necessarily correct
>>> to abort D and reject D as non-halting >
>>> D correctly simulated by H cannot possibly reach the point in
>>> its own execution trace where it does the opposite of whatever
>>> value that H returns.
>>>
>>
>> Olcott's H is of the Han type, because it aborts the simulation and
>
> *PREMISE*
> *When one understands that simulating termination analyzer H*
> *is always correct to abort any simulation that cannot possibly*
> *stop running unless aborted
'H is correct to abort' So it should be of the Han type. Thus Dan,
derived from this Han, correctly simulated (Han(Dan,Dan) should simulate
its input Dan, not its non-input Dss which does not stop running), does
stop and it is incorrect to abort it. So, the premise causes a
contradiction, therefore the premise is false. So, such a H does not exist.

Now we get the non-existing D derived from this non-existing H.

>
> 01 int D(ptr x)  // ptr is pointer to int function
> 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 }
>

> *IS LOGICALLY ENTAILED FROM PREMISE*

The premise which is shown to be false. Which makes the following
sentences vacuous.

> Then every simulating termination analyzer H specified by
> the above template correctly aborts its simulation of D
> and correctly rejects D as non-halting.
>
> Pages 661 to 696 of Halt7.c specify the H that does this
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
> This is true because halt deciders are requires to report on
> the behavior that their input finite string specifies and
> are not allowed to report on any other behavior.
>
> It is proven above that D does specify recursive simulation
> to H. Some idiots seem to believe that H must ignore the
> call to H(D,D) from D.
>

On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 17:41 schreef olcott:
>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>> I have already been completely through your idea with hundreds of
>>>>>>>> posts on another forum with someone else before I determined that
>>>>>>>> it is nonsense using set theory.
>>>>>>>
>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>
>>>>>>> The halting problem is to decide whether the execution sequence
>>>>>>> of a Turing machine/input pair is finite or infinite.
>>>>>>>
>>>>>>
>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>> can only take finite strings as input.
>>>>>>
>>>>>> The halting problem is whether or not a finite string pair
>>>>>> (TM description and its input)
>>>>>>
>>>>>> *specifies a finite sequence of configurations*
>>>>>> *specifies a finite sequence of configurations*
>>>>>> *specifies a finite sequence of configurations*
>>>>>>
>>>>>
>>>>> The halting problem is whether or not you get a finite sequence of
>>>>> configurations when you execute the finite string pair according to
>>>>> Turing Machine rules and no other rules.
>>>>
>>>> *No that is a common misconception*
>>>> The halting problem is actually about computing the mapping
>>>> from an input finite string pair such the the first element of
>>>> this pair species behavior. It is the behavior that this finite
>>>> string specifies that must be reported on.
>>>>
>>>> When D does call H in recursive simulation such that D cannot
>>>> possibly stop running unless aborted the H is necessarily correct
>>>> to abort D and reject D as non-halting >
>>>> D correctly simulated by H cannot possibly reach the point in
>>>> its own execution trace where it does the opposite of whatever
>>>> value that H returns.
>>>>
>>>
>>> Olcott's H is of the Han type, because it aborts the simulation and
>>
>> *PREMISE*
>> *When one understands that simulating termination analyzer H*
>> *is always correct to abort any simulation that cannot possibly*
>> *stop running unless aborted
> 'H is correct to abort' So it should be of the Han type. Thus Dan,
> derived from this Han, correctly simulated (Han(Dan,Dan) should simulate
> its input Dan, not its non-input Dss which does not stop running), does
> stop and it is incorrect to abort it. So, the premise causes a
> contradiction, therefore the premise is false. So, such a H does not exist.
>
> Now we get the non-existing D derived from this non-existing H.
>
>>
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 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 }
>>
>
>> *IS LOGICALLY ENTAILED FROM PREMISE*
>
> The premise which is shown to be false. Which makes the following
> sentences vacuous.
>

All halt deciders must report on what the behavior of their
input would be. None are required to infinitely simulate
their input to correctly determine that their input would
never halt.

The halt status criteria defined as comments to the function
body of H

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

Conclusively prove that they are correct to anyone with
sufficient software engineering skill.

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

Op 31.jan.2024 om 18:16 schreef olcott:
> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 17:41 schreef olcott:
>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>> I have already been completely through your idea with hundreds of
>>>>>>>>> posts on another forum with someone else before I determined that
>>>>>>>>> it is nonsense using set theory.
>>>>>>>>
>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>
>>>>>>>> The halting problem is to decide whether the execution sequence
>>>>>>>> of a Turing machine/input pair is finite or infinite.
>>>>>>>>
>>>>>>>
>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>> can only take finite strings as input.
>>>>>>>
>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>> (TM description and its input)
>>>>>>>
>>>>>>> *specifies a finite sequence of configurations*
>>>>>>> *specifies a finite sequence of configurations*
>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>
>>>>>>
>>>>>> The halting problem is whether or not you get a finite sequence of
>>>>>> configurations when you execute the finite string pair according
>>>>>> to Turing Machine rules and no other rules.
>>>>>
>>>>> *No that is a common misconception*
>>>>> The halting problem is actually about computing the mapping
>>>>> from an input finite string pair such the the first element of
>>>>> this pair species behavior. It is the behavior that this finite
>>>>> string specifies that must be reported on.
>>>>>
>>>>> When D does call H in recursive simulation such that D cannot
>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>> to abort D and reject D as non-halting >
>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>> its own execution trace where it does the opposite of whatever
>>>>> value that H returns.
>>>>>
>>>>
>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>
>>> *PREMISE*
>>> *When one understands that simulating termination analyzer H*
>>> *is always correct to abort any simulation that cannot possibly*
>>> *stop running unless aborted
>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>> simulate its input Dan, not its non-input Dss which does not stop
>> running), does stop and it is incorrect to abort it. So, the premise
>> causes a contradiction, therefore the premise is false. So, such a H
>> does not exist.
>>
>> Now we get the non-existing D derived from this non-existing H.
>>
>>>
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 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 }
>>>
>>
>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>
>> The premise which is shown to be false. Which makes the following
>> sentences vacuous.
>>
>
> All halt deciders must report on what the behavior of their
> input would be. None are required to infinitely simulate
> their input to correctly determine that their input would
> never halt.

Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which aborts
and returns a halting state, so it is not true that it never halts.
Han(Dan,Dan) must not report on Dss, based on Hss that simulates infinitely.
So, olcott agrees that the premise is incorrect if it claims that Dan
must be aborted, because that is only true if Han reports on its non-input.

On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 18:16 schreef olcott:
>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>> I have already been completely through your idea with hundreds of
>>>>>>>>>> posts on another forum with someone else before I determined that
>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>
>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>
>>>>>>>>> The halting problem is to decide whether the execution sequence
>>>>>>>>> of a Turing machine/input pair is finite or infinite.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>> can only take finite strings as input.
>>>>>>>>
>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>> (TM description and its input)
>>>>>>>>
>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>
>>>>>>>
>>>>>>> The halting problem is whether or not you get a finite sequence
>>>>>>> of configurations when you execute the finite string pair
>>>>>>> according to Turing Machine rules and no other rules.
>>>>>>
>>>>>> *No that is a common misconception*
>>>>>> The halting problem is actually about computing the mapping
>>>>>> from an input finite string pair such the the first element of
>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>> string specifies that must be reported on.
>>>>>>
>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>> to abort D and reject D as non-halting >
>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>> its own execution trace where it does the opposite of whatever
>>>>>> value that H returns.
>>>>>>
>>>>>
>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>
>>>> *PREMISE*
>>>> *When one understands that simulating termination analyzer H*
>>>> *is always correct to abort any simulation that cannot possibly*
>>>> *stop running unless aborted
>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>> simulate its input Dan, not its non-input Dss which does not stop
>>> running), does stop and it is incorrect to abort it. So, the premise
>>> causes a contradiction, therefore the premise is false. So, such a H
>>> does not exist.
>>>
>>> Now we get the non-existing D derived from this non-existing H.
>>>
>>>>
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 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 }
>>>>
>>>
>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>
>>> The premise which is shown to be false. Which makes the following
>>> sentences vacuous.
>>>
>>
>> All halt deciders must report on what the behavior of their
>> input would be. None are required to infinitely simulate
>> their input to correctly determine that their input would
>> never halt.
>
> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which aborts

I have spent far too many weeks on this convoluted bullshit Dennis Bush
mostly on another forum.

There is one infinite set of H/D pairs where every H correctly
determines the halt status of its corresponding D every other
freaking thing else is a dishonest dodge away from the point.

I spent a dozen years on the Dishonest dodges of Ben Bacarisse
before I stopped tolerating them from anyone.

> and returns a halting state, so it is not true that it never halts.
> Han(Dan,Dan) must not report on Dss, based on Hss that simulates
> infinitely.
> So, olcott agrees that the premise is incorrect if it claims that Dan
> must be aborted, because that is only true if Han reports on its non-input.
>

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

Op 31.jan.2024 om 23:04 schreef olcott:
> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 18:16 schreef olcott:
>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>> hundreds of
>>>>>>>>>>> posts on another forum with someone else before I determined
>>>>>>>>>>> that
>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>
>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>
>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>> can only take finite strings as input.
>>>>>>>>>
>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>> (TM description and its input)
>>>>>>>>>
>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>
>>>>>>>>
>>>>>>>> The halting problem is whether or not you get a finite sequence
>>>>>>>> of configurations when you execute the finite string pair
>>>>>>>> according to Turing Machine rules and no other rules.
>>>>>>>
>>>>>>> *No that is a common misconception*
>>>>>>> The halting problem is actually about computing the mapping
>>>>>>> from an input finite string pair such the the first element of
>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>> string specifies that must be reported on.
>>>>>>>
>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>> to abort D and reject D as non-halting >
>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>> value that H returns.
>>>>>>>
>>>>>>
>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>
>>>>> *PREMISE*
>>>>> *When one understands that simulating termination analyzer H*
>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>> *stop running unless aborted
>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>> running), does stop and it is incorrect to abort it. So, the premise
>>>> causes a contradiction, therefore the premise is false. So, such a H
>>>> does not exist.
>>>>
>>>> Now we get the non-existing D derived from this non-existing H.
>>>>
>>>>>
>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>> 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 }
>>>>>
>>>>
>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>
>>>> The premise which is shown to be false. Which makes the following
>>>> sentences vacuous.
>>>>
>>>
>>> All halt deciders must report on what the behavior of their
>>> input would be. None are required to infinitely simulate
>>> their input to correctly determine that their input would
>>> never halt.
>>
>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which aborts
>
> I have spent far too many weeks on this convoluted bullshit Dennis Bush
> mostly on another forum.
>
> There is one infinite set of H/D pairs where every H correctly
> determines the halt status of its corresponding D every other
> freaking thing else is a dishonest dodge away from the point.
>
> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
> before I stopped tolerating them from anyone.
>

Strange. Most people will understand that olcotts claim is false within
a few days, but olcott does not even understand it after a dozen years.
I am afraid he will need an infinite time to understand it. Probably a
bug in the AI.

On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 23:04 schreef olcott:
>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>> hundreds of
>>>>>>>>>>>> posts on another forum with someone else before I determined
>>>>>>>>>>>> that
>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>
>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>
>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>> (TM description and its input)
>>>>>>>>>>
>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The halting problem is whether or not you get a finite sequence
>>>>>>>>> of configurations when you execute the finite string pair
>>>>>>>>> according to Turing Machine rules and no other rules.
>>>>>>>>
>>>>>>>> *No that is a common misconception*
>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>> string specifies that must be reported on.
>>>>>>>>
>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>> value that H returns.
>>>>>>>>
>>>>>>>
>>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>>
>>>>>> *PREMISE*
>>>>>> *When one understands that simulating termination analyzer H*
>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>> *stop running unless aborted
>>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>>> running), does stop and it is incorrect to abort it. So, the
>>>>> premise causes a contradiction, therefore the premise is false. So,
>>>>> such a H does not exist.
>>>>>
>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>
>>>>>>
>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>> 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 }
>>>>>>
>>>>>
>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>
>>>>> The premise which is shown to be false. Which makes the following
>>>>> sentences vacuous.
>>>>>
>>>>
>>>> All halt deciders must report on what the behavior of their
>>>> input would be. None are required to infinitely simulate
>>>> their input to correctly determine that their input would
>>>> never halt.
>>>
>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which aborts
>>
>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>> mostly on another forum.
>>
>> There is one infinite set of H/D pairs where every H correctly
>> determines the halt status of its corresponding D every other
>> freaking thing else is a dishonest dodge away from the point.
>>
>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>> before I stopped tolerating them from anyone.
>>
>
> Strange. Most people will understand that olcotts claim is false within
> a few days, but olcott does not even understand it after a dozen years.
> I am afraid he will need an infinite time to understand it. Probably a
> bug in the AI.
>

Three PhD computer science professors agree.

Does the halting problem place an actual limit on computation?
https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation

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

On 2/1/24 9:11 AM, olcott wrote:
> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 23:04 schreef olcott:
>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>> determined that
>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>
>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>
>>>>>>>>> *No that is a common misconception*
>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>
>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>> value that H returns.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>>>
>>>>>>> *PREMISE*
>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>> *stop running unless aborted
>>>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>>>> running), does stop and it is incorrect to abort it. So, the
>>>>>> premise causes a contradiction, therefore the premise is false.
>>>>>> So, such a H does not exist.
>>>>>>
>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 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 }
>>>>>>>
>>>>>>
>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>
>>>>>> The premise which is shown to be false. Which makes the following
>>>>>> sentences vacuous.
>>>>>>
>>>>>
>>>>> All halt deciders must report on what the behavior of their
>>>>> input would be. None are required to infinitely simulate
>>>>> their input to correctly determine that their input would
>>>>> never halt.
>>>>
>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>> aborts
>>>
>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>> mostly on another forum.
>>>
>>> There is one infinite set of H/D pairs where every H correctly
>>> determines the halt status of its corresponding D every other
>>> freaking thing else is a dishonest dodge away from the point.
>>>
>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>> before I stopped tolerating them from anyone.
>>>
>>
>> Strange. Most people will understand that olcotts claim is false
>> within a few days, but olcott does not even understand it after a
>> dozen years. I am afraid he will need an infinite time to understand
>> it. Probably a bug in the AI.
>>
>
> Three PhD computer science professors agree.
>
> Does the halting problem place an actual limit on computation?
> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>

Fallacy of "proof" by authority.

You all are making the same mistake,

On 2/1/2024 9:39 PM, Richard Damon wrote:
> On 2/1/24 9:11 AM, olcott wrote:
>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>>
>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>
>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>> value that H returns.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation
>>>>>>>>> and
>>>>>>>>
>>>>>>>> *PREMISE*
>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>> *stop running unless aborted
>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>> not stop running), does stop and it is incorrect to abort it. So,
>>>>>>> the premise causes a contradiction, therefore the premise is
>>>>>>> false. So, such a H does not exist.
>>>>>>>
>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 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 }
>>>>>>>>
>>>>>>>
>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>
>>>>>>> The premise which is shown to be false. Which makes the following
>>>>>>> sentences vacuous.
>>>>>>>
>>>>>>
>>>>>> All halt deciders must report on what the behavior of their
>>>>>> input would be. None are required to infinitely simulate
>>>>>> their input to correctly determine that their input would
>>>>>> never halt.
>>>>>
>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>> aborts
>>>>
>>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>>> mostly on another forum.
>>>>
>>>> There is one infinite set of H/D pairs where every H correctly
>>>> determines the halt status of its corresponding D every other
>>>> freaking thing else is a dishonest dodge away from the point.
>>>>
>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>> before I stopped tolerating them from anyone.
>>>>
>>>
>>> Strange. Most people will understand that olcotts claim is false
>>> within a few days, but olcott does not even understand it after a
>>> dozen years. I am afraid he will need an infinite time to understand
>>> it. Probably a bug in the AI.
>>>
>>
>> Three PhD computer science professors agree.
>>
>> Does the halting problem place an actual limit on computation?
>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>
>
> Fallacy of "proof" by authority.
>
> You all are making the same mistake,

Qualified expert means an individual who has satisfactorily fulfilled
the training and experience requirements consistent with achieving a
level of competency sufficient to function effectively in the position
for which registration is sought.
https://www.lawinsider.com/dictionary/qualified-expert#

*Within inductive inference One is allowed to appeal*
*to the authority of a qualified expert*
https://philosophy.stackexchange.com/questions/73124/what-fallacy-or-appeal-occurs-when-one-feigns-to-be-more-educated-knowledgeable

Evidence as if submitted in court.

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

Op 01.feb.2024 om 15:11 schreef olcott:
> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 23:04 schreef olcott:
>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>> determined that
>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>
>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>
>>>>>>>>> *No that is a common misconception*
>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>
>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>> value that H returns.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>>>
>>>>>>> *PREMISE*
>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>> *stop running unless aborted
>>>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>>>> running), does stop and it is incorrect to abort it. So, the
>>>>>> premise causes a contradiction, therefore the premise is false.
>>>>>> So, such a H does not exist.
>>>>>>
>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 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 }
>>>>>>>
>>>>>>
>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>
>>>>>> The premise which is shown to be false. Which makes the following
>>>>>> sentences vacuous.
>>>>>>
>>>>>
>>>>> All halt deciders must report on what the behavior of their
>>>>> input would be. None are required to infinitely simulate
>>>>> their input to correctly determine that their input would
>>>>> never halt.
>>>>
>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>> aborts
>>>
>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>> mostly on another forum.
>>>
>>> There is one infinite set of H/D pairs where every H correctly
>>> determines the halt status of its corresponding D every other
>>> freaking thing else is a dishonest dodge away from the point.
>>>
>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>> before I stopped tolerating them from anyone.
>>>
>>
>> Strange. Most people will understand that olcotts claim is false
>> within a few days, but olcott does not even understand it after a
>> dozen years. I am afraid he will need an infinite time to understand
>> it. Probably a bug in the AI.
>>
>
> Three PhD computer science professors agree.

If true, I am very sorry for those professors.
My son, working for Google, told me that the Google search engine is so
strong, that for every false statement one can find a few professors
that seem to defend it.

On 2/2/24 2:16 AM, olcott wrote:
> On 2/1/2024 9:39 PM, Richard Damon wrote:
>> On 2/1/24 9:11 AM, olcott wrote:
>>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or
>>>>>>>>>>>>>> infinite.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>>> sequence of configurations when you execute the finite
>>>>>>>>>>>> string pair according to Turing Machine rules and no other
>>>>>>>>>>>> rules.
>>>>>>>>>>>
>>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>>
>>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>>> possibly stop running unless aborted the H is necessarily
>>>>>>>>>>> correct
>>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>>> value that H returns.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Olcott's H is of the Han type, because it aborts the
>>>>>>>>>> simulation and
>>>>>>>>>
>>>>>>>>> *PREMISE*
>>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>>> *stop running unless aborted
>>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>>> not stop running), does stop and it is incorrect to abort it.
>>>>>>>> So, the premise causes a contradiction, therefore the premise is
>>>>>>>> false. So, such a H does not exist.
>>>>>>>>
>>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>
>>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>>
>>>>>>>> The premise which is shown to be false. Which makes the
>>>>>>>> following sentences vacuous.
>>>>>>>>
>>>>>>>
>>>>>>> All halt deciders must report on what the behavior of their
>>>>>>> input would be. None are required to infinitely simulate
>>>>>>> their input to correctly determine that their input would
>>>>>>> never halt.
>>>>>>
>>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>>> aborts
>>>>>
>>>>> I have spent far too many weeks on this convoluted bullshit Dennis
>>>>> Bush
>>>>> mostly on another forum.
>>>>>
>>>>> There is one infinite set of H/D pairs where every H correctly
>>>>> determines the halt status of its corresponding D every other
>>>>> freaking thing else is a dishonest dodge away from the point.
>>>>>
>>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>>> before I stopped tolerating them from anyone.
>>>>>
>>>>
>>>> Strange. Most people will understand that olcotts claim is false
>>>> within a few days, but olcott does not even understand it after a
>>>> dozen years. I am afraid he will need an infinite time to understand
>>>> it. Probably a bug in the AI.
>>>>
>>>
>>> Three PhD computer science professors agree.
>>>
>>> Does the halting problem place an actual limit on computation?
>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>
>>
>> Fallacy of "proof" by authority.
>>
>> You all are making the same mistake,
>
> Qualified expert means an individual who has satisfactorily fulfilled
> the training and experience requirements consistent with achieving a
> level of competency sufficient to function effectively in the position
> for which registration is sought.
> https://www.lawinsider.com/dictionary/qualified-expert#

Still FALLACY OF APPEAL TO AUTHORITY.

Being a qualified expert may allow allow you to testify in court as an
expert, UNDER THE PENALTY OF PREJURY and thus overt liars end up in jail.

On 2/2/2024 5:16 AM, Fred. Zwarts wrote:
> Op 01.feb.2024 om 15:11 schreef olcott:
>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>>
>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>
>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>> value that H returns.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation
>>>>>>>>> and
>>>>>>>>
>>>>>>>> *PREMISE*
>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>> *stop running unless aborted
>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>> not stop running), does stop and it is incorrect to abort it. So,
>>>>>>> the premise causes a contradiction, therefore the premise is
>>>>>>> false. So, such a H does not exist.
>>>>>>>
>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 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 }
>>>>>>>>
>>>>>>>
>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>
>>>>>>> The premise which is shown to be false. Which makes the following
>>>>>>> sentences vacuous.
>>>>>>>
>>>>>>
>>>>>> All halt deciders must report on what the behavior of their
>>>>>> input would be. None are required to infinitely simulate
>>>>>> their input to correctly determine that their input would
>>>>>> never halt.
>>>>>
>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>> aborts
>>>>
>>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>>> mostly on another forum.
>>>>
>>>> There is one infinite set of H/D pairs where every H correctly
>>>> determines the halt status of its corresponding D every other
>>>> freaking thing else is a dishonest dodge away from the point.
>>>>
>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>> before I stopped tolerating them from anyone.
>>>>
>>>
>>> Strange. Most people will understand that olcotts claim is false
>>> within a few days, but olcott does not even understand it after a
>>> dozen years. I am afraid he will need an infinite time to understand
>>> it. Probably a bug in the AI.
>>>
>>
>> Three PhD computer science professors agree.
>
> If true, I am very sorry for those professors.
> My son, working for Google, told me that the Google search engine is so
> strong, that for every false statement one can find a few professors
> that seem to defend it.

Does the halting problem place an actual limit on computation?
https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation

Since I independently came up with this same reasoning back in 2004
(as referenced in my paper) I understand how and why they are correct.
Even "Carol's question" was directed at me as Jack's question in 2004.

So far not a single person could ever show any actual error in my
reasoning all they ever have is the dogma that they really really
believe that I am wrong. They try to get away with using rhetoric
instead of reasoning. This only works on gullible fools.

Any question intentionally defined to have no correct
answer <is> an incorrect question.

Any decision problem intentionally defined to be unsatisfiable
is isomorphic to an incorrect question.

The inability to answer an incorrect question places
no actual limit on anyone or anything.

Professor Hehner did a beautiful in showing that the context
of who is asked a question changed the meaning of this question.

You can comprehend this or fail to comprehend this. Because it
is a self-evident truth correct rebuttals are impossible.

On 2/2/24 10:48 AM, olcott wrote:
> On 2/2/2024 5:16 AM, Fred. Zwarts wrote:
>> Op 01.feb.2024 om 15:11 schreef olcott:
>>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or
>>>>>>>>>>>>>> infinite.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>>> sequence of configurations when you execute the finite
>>>>>>>>>>>> string pair according to Turing Machine rules and no other
>>>>>>>>>>>> rules.
>>>>>>>>>>>
>>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>>
>>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>>> possibly stop running unless aborted the H is necessarily
>>>>>>>>>>> correct
>>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>>> value that H returns.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Olcott's H is of the Han type, because it aborts the
>>>>>>>>>> simulation and
>>>>>>>>>
>>>>>>>>> *PREMISE*
>>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>>> *stop running unless aborted
>>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>>> not stop running), does stop and it is incorrect to abort it.
>>>>>>>> So, the premise causes a contradiction, therefore the premise is
>>>>>>>> false. So, such a H does not exist.
>>>>>>>>
>>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>
>>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>>
>>>>>>>> The premise which is shown to be false. Which makes the
>>>>>>>> following sentences vacuous.
>>>>>>>>
>>>>>>>
>>>>>>> All halt deciders must report on what the behavior of their
>>>>>>> input would be. None are required to infinitely simulate
>>>>>>> their input to correctly determine that their input would
>>>>>>> never halt.
>>>>>>
>>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>>> aborts
>>>>>
>>>>> I have spent far too many weeks on this convoluted bullshit Dennis
>>>>> Bush
>>>>> mostly on another forum.
>>>>>
>>>>> There is one infinite set of H/D pairs where every H correctly
>>>>> determines the halt status of its corresponding D every other
>>>>> freaking thing else is a dishonest dodge away from the point.
>>>>>
>>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>>> before I stopped tolerating them from anyone.
>>>>>
>>>>
>>>> Strange. Most people will understand that olcotts claim is false
>>>> within a few days, but olcott does not even understand it after a
>>>> dozen years. I am afraid he will need an infinite time to understand
>>>> it. Probably a bug in the AI.
>>>>
>>>
>>> Three PhD computer science professors agree.
>>
>> If true, I am very sorry for those professors.
>> My son, working for Google, told me that the Google search engine is
>> so strong, that for every false statement one can find a few
>> professors that seem to defend it.
>
> Does the halting problem place an actual limit on computation?

That is an interesting philosophical question. Does knowing you have the
limit actual cause the limit or not.

Without the "Halting Problem" and its proof, Computations still could
compute the things they couldn't compute (and a lot of the things they
can't compute are not directly Halting Problems).

So, the knowledge of the Halting Problem doesn't actually create a limit
on computations, it just shows some of the limits that actually exist.

On 31/01/24 17:41, olcott wrote:
> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 16:54 schreef olcott:
>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>> On 1/31/24 01:56, olcott wrote:
>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>> I have already been completely through your idea with hundreds of
>>>>>>> posts on another forum with someone else before I determined that
>>>>>>> it is nonsense using set theory.
>>>>>>
>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>
>>>>>> The halting problem is to decide whether the execution sequence of
>>>>>> a Turing machine/input pair is finite or infinite.
>>>>>>
>>>>>
>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>> can only take finite strings as input.
>>>>>
>>>>> The halting problem is whether or not a finite string pair
>>>>> (TM description and its input)
>>>>>
>>>>> *specifies a finite sequence of configurations*
>>>>> *specifies a finite sequence of configurations*
>>>>> *specifies a finite sequence of configurations*
>>>>>
>>>>
>>>> The halting problem is whether or not you get a finite sequence of
>>>> configurations when you execute the finite string pair according to
>>>> Turing Machine rules and no other rules.
>>>
>>> *No that is a common misconception*
>>> The halting problem is actually about computing the mapping
>>> from an input finite string pair such the the first element of
>>> this pair species behavior. It is the behavior that this finite
>>> string specifies that must be reported on.
>>>
>>> When D does call H in recursive simulation such that D cannot
>>> possibly stop running unless aborted the H is necessarily correct
>>> to abort D and reject D as non-halting >
>>> D correctly simulated by H cannot possibly reach the point in
>>> its own execution trace where it does the opposite of whatever
>>> value that H returns.
>>>
>>
>> Olcott's H is of the Han type, because it aborts the simulation and
>
> *PREMISE*
> *When one understands that simulating termination analyzer H*
> *is always correct to abort any simulation that cannot possibly*
> *stop running unless aborted*
>

Olcott has decided to turn his brain off, and instead of reading what I
said, he merely repeats the same magic incantation in the hopes that
magic is real.

On 1/02/24 10:48, Fred. Zwarts wrote:
>
> Strange. Most people will understand that olcotts claim is false within
> a few days, but olcott does not even understand it after a dozen years.
> I am afraid he will need an infinite time to understand it. Probably a
> bug in the AI.
>
The true Olcott Halting Problem is whether Olcott himself will halt
after a finite number of steps.